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

1. 本周学习总结

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

---

2. 书面作业

本次PTA作业题集多线程

1. 互斥访问与同步访问

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

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

• Condition是配合Lock使用的，而wait/notify是配合synchronized使用的。

锁对象ReentrantLock，lock，unlock方法，举例如下：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Account {
	private int balance;
	private Lock lock = new ReentrantLock();
	private Condition plus  = lock.newCondition(); 
	public Account(int balance) {
		super();
		this.balance = balance;
	}

	public int getBalance() {
		return balance;
	}

	public void deposit(int money) {// synchronized
		lock.lock();
		try {
			balance += money;
			plus.signalAll();//唤醒所有等待线程
		} finally {
			lock.unlock();
		}
	}

	public void withdraw(int money) {// synchronized
		lock.lock();
		try {
			while (getBalance() <= 0) {
				try{
				plus.await();//造成当前线程在接到信号或被中断之前一直处于等待状态。
				}catch(InterruptedException e){
					throw new RuntimeException(e);//必须处理或者抛出到出错的地方
				}
			}
			balance -= money;
		} finally {
			lock.unlock();
		}
	}
}

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

• 同步方法是在原子操作的程序代码前添加synchronized关键字，如：

        public static synchronized void addld(){
                id++;
        }

• 同步代码块是在方法中添加synchronized代码块，如：

        public static void addld(){
                synchronized(Counter.class){//synchronized(syncObject)，syncObject==上锁对象
                        id++;
                }
        }

• synchronized块其中的代码必须获得对象syncObject（可以是类实例或类）的锁方能执行。

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

通过对象锁实现了互斥访问。当一个线程访问共享资源时给该资源上一把锁，其他线程无法访问共享资源，等待直至该资源被解锁。共享资源被解锁后，任一线程可给共享资源上锁并访问该资源。如 public static synchronized void addld(){id++;}当某一线程访问该方法时，其他线程其他线程无法访问该方法，当该线程访问完之后，其他线程才可以逐一访问，总之，不同线程不能同时为一个对象上锁。

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

多个线程通过synchronized关键字这种方式来实现线程间的通信。这种方式本质上就是“共享内存”式的通信。多个线程需要访问同一个共享资源，谁拿到了锁（获得了访问权限），谁就可以执行。所以同步访问一般都要放到synchronized方法或者代码块中，避免了因同步访问而造成的共享资源不完整。

2. 交替执行

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

关键代码：

• 要有一个标志boolean值来判断执行哪块代码。
• 方法run1和run2是不能由一线程同时执行的，所以要用synchronized来修饰。
• 因为是两个线程交替执行，线程之间需要相互协作，所以使用了wait，notify，还有flag标志机制来实现。
• getSize()方法返回任务为完成的数量，当所有任务都完成后结束程序。

3. 互斥访问

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

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

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

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

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

多运行几次后发现仓库所剩货物不为0：

显然这结果不正常。正常放入100个，取出100个后还剩0个。当共享仓库只能存放一个数据时会产生以下问题：

1. 生产者比消费者快时，消费者来不及取数据；
2. 消费者比生产者快时，消费者可能取不到数据。

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

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

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

360百科说

如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样>的，就是线程安全的。

简单来说，线程安全就是说多线程访问同一代码，不会产生不确定的结果，即要控制多个线程对某个资源的有序访问或修改。
以下举一个线程不安全的例子：

多运行几次我们发现结果很多样化:

当然了，我们可以用一些方法修改自己的代码，让多线程访问同一代码，产生的是确定的一样的结果。
线程的同步是为了防止多个线程访问一个数据对象时，对数据造成的破坏，也就解决了线程安全问题。上文中的一些问题的解答包含线程同步方法。

6. 选做：实验总结

6.1 4-8（CountDownLatch）实验总结

• CountDownLatch是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
• CountDownLatch的其中一种典型用法是，将一个问题分成 N 个部分，用执行每个部分并让锁存器倒计数的 Runnable 来描述每个部分，然后将所有 Runnable 加入到 Executor 队列。当所有的子部分完成后，协调线程就能够通过 await。

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

通过查资料可以知道Collections类中有一些同步方法：

我们来看其中的synchronizedList方法：

根据需要我们可以调用特定的方法，以达到集合同步。

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

Runnable接口中的public void run()方法无返回值，如果我们希望线程运算后将结果返回，使用Runnable就无能为力。这时候我们应使用Callable。Callable代表有返回值的任务。
本题要求解前n项斐波那契数的和，Callable接口中的Call()方法要这样写：

Future 表示异步计算的结果，它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。

这道题我们用到了Callable和Futrue，

		List<CalculateTask> taskList = new ArrayList<CalculateTask>();
		List<Future<Integer>> results = new ArrayList<Future<Integer>>();
		for (int i = 0; i < n; i++) {
			taskList.add(new CalculateTask(i));
		}
		for (int i = 0; i < n; i++) {
			results.add(exec.submit(taskList.get(i)));
		}

taskList是任务列表，results是结果列表:存放任务完成返回的值。

可以用一个匿名内部类的写法来表述Callable和Futrue的使用关系：

    Future<V> future = executor.submit(new Callable<V>() {
         public V call() {
             ...
         });

以上是单个提交submit，还有一个批量运行所有任务的方法invokeAll，就本题来说可以这么写：

		try{
			results = exec.invokeAll(taskList);
		} catch (InterruptedException e) {
		    e.printStackTrace();
		}

---

3. 码云上代码提交记录

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

3.1. 码云代码提交记录

在码云的项目中，依次选择“统计-Commits历史-设置时间段”, 然后搜索并截图

3.2 截图多线程PTA提交列表