201521123076 《Java程序设计》第11周学习总结

1. 本周学习总结

1.1 以你喜欢的方式（思维导图或其他）归纳总结多线程相关内容。

2. 书面作业

本次PTA作业题集多线程

1.互斥访问与同步访问

完成题集4-4(互斥访问)与4-5(同步访问)

1.1 除了使用synchronized修饰方法实现互斥同步访问，还有什么办法实现互斥同步访问（请出现相关代码）？

使用ReentrantLock
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;
    }
}

1.2 同步代码块与同步方法有何区别？

相比于同步方法，同步代码块不是对整个方法同步控制，而是对你想进行同步控制的部分代码进行操作（用Synchronized (this){}获取对象锁)。而同步方法默认获取对象的锁，也就是两个同步方法不能同时获取到对象的锁。

1.3 实现互斥访问的原理是什么？请使用对象锁概念并结合相应的代码块进行说明。当程序执行synchronized同步代码块或者同步方法时，线程的状态是怎么变化的？

class Counter {
	private static int id = 0;

	public static  void addId() {
		synchronized (Counter.class) {
			id++;
		}
		
	}

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

	public static int getId() {
		return id;
	}
}  

每个对象都有一个锁，当哪个方法或者代码块获取到这个锁的时候，相应的，这个对象只能被其进行操作，而不能同时被其他没有获取到锁的方法或者代码块操作，此即实现了互斥访问。 就以上代码而言：假如有两个线程同时执行Counter类subtractId()和addId()方法（假设subtractId()先），那么只会执行id--操作，即id的值变为 -1 ，接着执行addId()，此时使用id的值为 -1 ，所以自增完变成0。最终值为0；

class Counter {
	private static int id = 0;

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

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

	public static int getId() {
		return id;
	}
}  

但是如果subtractId()方法没有用synchronized修饰，addId()内的id++代码块也没有使用synchronized (Counter.class)，那么执行同样的操作的时候，subtractId()调用id = 0，变成 -1 ， addId()调用id = 0，变成1，subtractId()将 -1 赋予id ，addId()将 1 赋予id,最终答案会变成1而不是0。可见，如果有不同的方法对同一资源同时进行操作的时候，如果没有实现互斥访问，可能会达不到我们预期的效果。

1.4 Java多线程中使用什么关键字实现线程之间的通信，进而实现线程的协同工作？为什么同步访问一般都要放到synchronized方法或者代码块中？

wait()、notify()等关键字。同步访问放到synchronized方法或者代码块中可以防止多个线程同时操作同一资源引起的冲突问题。

2.交替执行

实验总结（不管有没有做出来）

class Worker1 implements Runnable{
	private Repo repo;
	public Worker1(Repo repo){
		this.repo = repo;
	}
	@Override
	public  void run() {
		while(repo.getSize() != 0){
		if(Repo.flag1 == true){
		System.out.println(Thread.currentThread().getName()+ " finish " + repo.delTask());
		 Repo.flag1 = false;
		 Repo.flag2 = true;
		}
		}
		
	}
	
} 

class Worker2  implements Runnable{
	private Repo repo;
	public Worker2(Repo repo){
		this.repo = repo;
	}
	@Override
	public   void run() {
		
		while(repo.getSize() != 0){
			if(Repo.flag2 == true){
				System.out.println(Thread.currentThread().getName()+ " finish " + repo.delTask());
				 Repo.flag2 = false;
				 Repo.flag1 = true;
			}
	}
}
}

使用两个flag实现交替执行。

3.互斥访问

3.1 修改TestUnSynchronizedThread.java源代码使其可以同步访问。(关键代码截图，需出现学号)

3.2 进一步使用执行器改进相应代码(关键代码截图，需出现学号)

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

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

4.1 运行MyProducerConsumerTest.java。正常运行结果应该是仓库还剩0个货物。多运行几次，观察结果，并回答：结果正常吗？哪里不正常？为什么？

结果会不正常，剩余货物可能不为0，因为消费者生产者存取速度不一，可能出现库存为0还在取货物的情况；

4.2 使用synchronized, wait, notify解决该问题(关键代码截图，需出现学号)

4.3 选做：使用Lock与Condition对象解决该问题。

private Lock  RepositoryLock= new ReentrantLock();
private Condition condition = RepositoryLock.newCondition();
public void add(String t) throws InterruptedException {
    RepositoryLock.lock();
    try{
         while(repo.size()==capacity) 
             condition.await();
             if(repo.size()>capacity){
                    throw new IllegalArgumentException("商品数量超过最大容量");   
                }   
            repo.add(t);
            condition.signalAll();
         
    } finally
      {
        RepositoryLock.unlock();
      }
    
}
public   void remove() throws InterruptedException {
    RepositoryLock.lock();
    try{
        if(repo.size()==0){
             condition.await();
        }
        if(repo.size()<0){  
            throw new IllegalArgumentException("仓库内商品数量为负数");   
        }
        repo.remove(0);
        condition.signalAll();
    }finally
      {
        RepositoryLock.unlock();
      }
    
     
}

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

线程安全：指某个函数、函数库在多线程环境中被调用时，能够正确地处理多个线程之间的共享变量，使程序功能正确完成。

class Counter {
	private static int id = 0;

	public static  void addId() {
		synchronized (Counter.class) {
			id++;
		}
		
	}

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

	public static int getId() {
		return id;
	}
} 

---

class Counter {
	private static int id = 0;

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

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

	public static int getId() {
		return id;
	}
}   

就拿上面两段代码来说吧，根据维基百科的定义，可以判断代码1是现成安全的，代码2不是线程安全的，最根本的原因就是代码1正确地处理了多个线程之间的共享变量id，而代码2没有做到。

6选做：实验总结

6.1 4-8（CountDownLatch）实验总结

CountDownLatch latch = new CountDownLatch(n);等待所有任务结束。Executors.newFixedThreadPool(poolSize);生成包含poolSize线程的线程池，exec.execute(new MyTask(latch));使用poolSize个线程执行n个任务。

6.2 4-9（集合同步问题）实验总结

Main.list = Collections.synchronizedList(new ArrayList());调用Collections的synchronizedList()静态方法即可。

6.3 较难：4-10（Callable），并回答为什么有Runnable了还需要Callable？实验总结。

Runnable执行无返回值，而Callable有返回值。
在CalculateTask中定义一个方法public Integer fib(int m )用于计算n的斐波那契值数值
在call()中return fib(n);
把值放入results中，最后遍历相加得到sum的值。

3. 码云上代码提交记录

题目集：多线程(4-4到4-10)

3.2 截图多线程PTA提交列表

)