201521123072《java程序设计》第十一周学习总结

201521123072《java程序设计》第十一周学习总结

1. 本周学习总结

2. 书面作业

互斥访问与同步访问

class Counter {
private static int id = 0;
private static Lock poolLock = new ReentrantLock();
public synchronized static void addId() {
id++;
}
public synchronized static void subtractId() {
id--;
}
public static int getId() {
return id;
}
}

class Counter {
private static int id = 0;
private static Lock poolLock = new ReentrantLock();
public  static  void addId() {
poolLock.lock();
id++;
poolLock.unlock();

}
public   static  void subtractId() {
poolLock.lock();
id--;
poolLock.unlock();
}
public static int getId() {
return id;
}
}

public static void addId() {
synchronized (Counter.class) {//代表Counter类型的对象
id++;
}
}

public synchronized static void subtractId() {
id--;
}

class Counter {
private static int id = 0;
private static Lock poolLock = new ReentrantLock();

public static void addId() {
synchronized (Counter.class) {//代表Counter类型的对象
id++;
}

}

public synchronized static void subtractId() {
id--;
}
}

synchronized (Counter.class)

这一句是获得Counter对象的内部锁，如果没有获得这个锁，那么下面的id++则不能运行，如果获得了锁，那么执行完id++后，则释放锁。

下面是线程状态转换的图：



由上图可知：

当程序执行synchronized同步代码块，首先要获得对象的内部锁，如果没有获得，则进入Wait Pool，等到内部锁被释放的时候，再进入lock pool,再运行；如果一开始就获得了内部锁，那么就直接进入lock pool,再运行

交替执行

public synchronized  void get1(){
while(i<item.length){
while(this.i%2==0){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+" finish "+this.item[0]);
this.delete();
this.i++;
notify();
}
}

public synchronized  void get2(){
while(i<item.length){
while(this.i%2!=0){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+" finish "+this.item[0]);
this.delete();
this.i++;
notify();
}
}

互斥访问

参考资料:Java多线程之Executor、ExecutorService、Executors、Callable、Future与FutureTask

线程间的合作：生产者消费者问题

运行结果如下，显然不正确





这里的程序存和取是同时进行的，这里会发生互斥，虽然解决了互斥，但是没有解决同步的问题，

private Lock  RepositoryLock= new ReentrantLock();
private Condition temp = RepositoryLock.newCondition();
private int capacity = 10;//仓库容量默认为10
private List<String> repo = new ArrayList<String>();// repo(仓库)，最多只能放10个
public void add(String t) throws InterruptedException {
RepositoryLock.lock();
try{
while(repo.size()==capacity)
temp.await();
if(repo.size()>capacity){
throw new IllegalArgumentException("商品数量超过最大容量");
}
repo.add(t);
temp.signalAll();

} finally
{
RepositoryLock.unlock();//退出互斥代码块。之所以放到finally，是保证如果发生异常，一定要退出。就不会出现死锁现象。
}

}
public   void remove() throws InterruptedException {
RepositoryLock.lock();
try{
if(repo.size()==0){
temp.await();
}
if(repo.size()<0){
throw new IllegalArgumentException("仓库内商品数量为负数");
}
repo.remove(0);
temp.signalAll();
}finally
{
RepositoryLock.unlock();//退出互斥代码块。之所以放到finally，是保证如果发生异常，一定要退出。就不会出现死锁现象。
}

}

查询资料回答：什么是线程安全？(用自己的话与代码总结，写自己看的懂的作业)

public static void addId() {
id++;
}
public static void subtractId() {
id--;
}

理想的结果应该是0，但是实际上每次程序运行都会有不同的结果，如下：

public static void addId() {
synchronized (Counter.class) {//代表Counter类型的对象
id++;
}
}
public synchronized static void subtractId() {
id--;
}

选做：实验总结

3. 码云上代码提交记录

3.1. 码云代码提交记录

3.2 截图多线程PTA提交列表