1. 本周学习总结
1.1 以你喜欢的方式（思维导图或其他）归纳总结多线程相关内容。
1、多线程的临界资源：启动多个线程同时运行时，需要同时访问共同的资源，导致结果的不正确性；
2、原子性操作：只进行单一的一次操作（包括取数据，加一，写入都算单独的一次操作），自加自减操作不是原子性操作；
3、synchronized：方法前用synchronized进行声明可以使当前线程执行完该方法后下一个线程才进入，保证了了共享资源的完整性与正确性；
4、使用synchronized的两种方法：原子操作的代码方法加synchronized修饰，或，方法下用synchronized (.class)封装；
5、synchronized 原理：当前线程取走当前对象唯一的锁，其他线程发现没有锁可取时就必须等待锁的归还；
6、多线程的同步：被声明为synchronized的方法或代码段中调用wait () 和notify()/notifyAll()；
7、wait():让当前线程释放对象锁；
8、notify()/notifyAll()：唤醒等待中的线程，加入同一个对象锁的队列；
2. 书面作业
本次PTA作业题集多线程
互斥访问与同步访问
完成题集4-4(互斥访问)与4-5(同步访问)
1.1 除了使用synchronized修饰方法实现互斥同步访问，还有什么办法实现互斥同步访问（请出现相关代码）？
可以使用java.util.concurrent.locks.*;包下的Condition类和Lock类；
public Account(int balance) {
super();
this.balance=balance;
accountlock = new ReentrantLock();
accountcon = accountlock.newCondition();
}
public synchronized void deposit(int money) {
accountlock.lock();//理解的是类似synchronized中的取锁操作；
this.balance = this.balance + money;
accountcon.signal();//相当于notify();
accountlock.unlock();//释放锁；
}
public synchronized void withdraw(int money) {
accountlock.lock();
while(this.balance - money<0){
try {
accountcon.await();//当出现当前的balance为0时，进入等待；
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
accountlock.unlock();
}
}
this.balance=this.balance-money;
if(balance<0) {
throw new IllegalStateException(balance+"");
}
}
1.2 同步代码块与同步方法有何区别？
同步方法是在方法声明的外部用Synchronized修饰的，可想而知，当前线程只有执行完了整个方法后才能轮到下一个线程，从而不会影响当前线程的结果；
而同步代码块可以对方法中的任意代码块进行操作，非同步代码块的部分相当于前者方法外的部分。
1.3 实现互斥访问的原理是什么？请使用对象锁概念并结合相应的代码块进行说明。当程序执行synchronized同步代码块或者同步方法时，线程的状态是怎么变化的？
public synchronized void deposit(int money) {
this.balance = this.balance + money;
notify();//当存款成功时唤醒队列中的等待线程进行取款，释放对象锁；
}
public synchronized void withdraw(int money) {
while(this.balance - money<0){
try {
wait();//获取对象锁，当发现余额不够提款时，进入Wait Pool中，直到当有接受到存款的唤醒信号时进入Lock Pool
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.balance=this.balance-money;
if(balance<0)
throw new IllegalStateException(balance+"");
}
1.4 Java多线程中使用什么关键字实现线程之间的通信，进而实现线程的协同工作？为什么同步访问一般都要放到synchronized方法或者代码块中？
1、多线程中通过wait(),notify()或notifyAll()，或者通过Lock对象和Condition对象来实现线程之间的通信，避免线程之间的冲突；
2、同步访问一样是会引起多线程之间的临界资源的冲突，放到Synchronized中可以避免多线程之间的冲突产生。
交替执行实验总结（未通过）
1、字符串进行分解时，一开始想用toCharArray的方法，但是这个方法是将字符串用字符数组存储，空格也会被单独存储，因此pass;
2、getSize（）返回repo的任务数量没办法将构造函数的rep（存放分解后的任务）获取；
3、boolean work1done;//新增两个标志；
boolean work2done;//用于两个线程交替完成任务互相通知判断的标志；
4、public Repo(String items) {
List<Integer> rep=new ArrayList<Integer>();
for (int i = 0; i < items.length(); i++) {
if(items.charAt(i)==' '){
continue;
}
rep.add((int) items.charAt(i));//分解任务，用rep存放
}
}
public synchronized void test1() {
while(!work2done){//进行任务1时，当任务2未完成则进入等待，直到任务2完成后唤醒；
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
notify();
}
public synchronized void test2(){
while(!work1done){//同，任务1未完成时，需要等到任务1完成后被唤醒
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
notify();//任务2完成后唤醒任务1
}
互斥访问
3.1 修改TestUnSynchronizedThread.java源代码使其可以同步访问。(关键代码截图，需出现学号)
3.2 进一步使用执行器改进相应代码(关键代码截图，需出现学号)
参考资料:Java多线程之Executor、ExecutorService、Executors、Callable、Future与FutureTask
线程间的合作：生产者消费者问题
4.1 运行MyProducerConsumerTest.java。正常运行结果应该是仓库还剩0个货物。多运行几次，观察结果，并回答：结果正常吗？哪里不正常？为什么？
三次运行结果都不一致；
结果自然是不正常的；
因为取货和存货的速度不一样，可能会出现供不应求或者供应过剩的问题；
4.2 使用synchronized, wait, notify解决该问题(关键代码截图，需出现学号)
public synchronized void add(String t) {
while (repo.size() >= capacity) {
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("仓库已满!无法添加货物。");
}
}
notify();
repo.add(t);
}
public synchronized void remove() {
while (repo.size() <= 0) {
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("仓库无货！无法从仓库取货");
}
}
notify();
repo.remove(0);
}
4.3 选做：使用Lock与Condition对象解决该问题。
public synchronized void add(String t) {
lock.lock();
while (repo.size() >= capacity) {
try {
condition.await();
lock.unlock();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("仓库已满!无法添加货物。");
}
}
lock.unlock();
condition.notify();
repo.add(t);
}
public synchronized void remove() {
lock.lock();
while (repo.size() <= 0) {
try {
condition.await();
lock.unlock();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("仓库无货！无法从仓库取货");
}
}
lock.unlock();
condition.notify();
repo.remove(0);
}
查询资料回答：什么是线程安全？(用自己的话与代码总结，写自己看的懂的作业)
public class testsafe {
public void count(){
size++;
}
}
线程安全就是多个线程执行一段操作语句，而这操作未结束时另一个线程开始占有这段操作的资源，引起的线程安全性的问题；
按资料上的ArrayList的栗子进行说明：对list进行add操作，将某个值放在了list的尾部，list.size未进行++操作时，线程2此时开始执行
又将某个值放在了同一个位置，size后才进行++，这就导致了值被覆盖并且size自加了两次
解决这个问题就是用synchronized修饰该操作使之执行完后才允许下一线程的执行。
选做：实验总结
6.1 4-8（CountDownLatch）实验总结
这题需要创建的是一个可重用固定线程数的线程池，使用的是Executors.newFixedThreadPool(int nThreads)
一开始把n误解为是Executors.newFixedThreadPool(int nThreads)的参数，poolSize作为CountDownLatch参数，导致运行时间超出
另外要注意MyTask的参数是CountDownLatch latch就行了
6.2 4-9（集合同步问题）实验总结
Collections.synchronizedList(new ArrayList())，可以使用多个线程同时频繁修改List来引发错误。
并且list返回的迭代器仍然不是一个安全的线程；
3. 码云上代码提交记录
3.1. 码云代码提交记录
3.2 截图多线程PTA提交列表
