201521123065《java程序设计》第11周学习总结

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提交列表