JAVA并发编程2
说明：先上代码，笔记后续补充
public class CoderTest1 {
private static Object key;
public static void main(String[] args) {
//同步容器 Vector HashTable Collections.synchronizedList()
//如果迭代过程中发生修改，并发修改异常 修改线程独立copy一份集合(这样会导致不能得到最新的数据，效率有影响)
/*多个线程操作容易抛出ArrayIndexOutOfBoundsException异常
* Vector<Object> vector = new Vector<>();
int lastSize = vector.size()-1;
vector.remove(lastSize);
* */
// Vector<Object> vector = new Vector<>();
// synchronized (key){
// int lastSize = vector.size()-1;
// vector.remove(lastSize);
// }
//这种情况会出现并发修改异常 ConcurrentModificationException
// ArrayList<Object> list = new ArrayList<>();
// list.add(1);
// list.add(1);
// list.add(1);
// list.add(1);
// list.add(1);
// for (Object obj : list){
// System.out.println(obj);
// list.remove(obj);
// }
//并发容器 ConcurrentHashMap 分段锁 每一个链表上一个锁，1.8之后好像是node锁
//map.putIfAbsent 只有key不存在才会操作成功，不会覆盖
//CopyOnWriteArrayList/Set 应用场景：读操作多，写操作很少
//阻塞队列
// 先进先出，如果队列为空则阻塞
// ConcurrentHashMap map = new ConcurrentHashMap();
// map.putIfAbsent(1,2);
// map.putIfAbsent(1,3);
// System.out.println(map);
//
// CopyOnWriteArrayList<Object> list = new CopyOnWriteArrayList<>();
// BlockingQueue queue = new ArrayBlockingQueue(2);
// 1闭锁 2栅栏 3信号量
//到达栅栏之后需要所有线程执行完之后才能继续执行其他线程
// final CountDownLatch latch = new CountDownLatch(2);
// //第一个线程
// new Thread(){
// public void run(){
// try {
// System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
// Thread.sleep(3000);
// System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
// latch.countDown();
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// }
// }.start();
// //第二个线程
// new Thread(){
// public void run(){
// try {
// System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
// Thread.sleep(3000);
// System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
// latch.countDown();
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// }
// }.start();
//
// try {
// System.out.println("等待两个子线程执行完毕。。。");
// //闭锁
// latch.await();
// System.out.println("两个子线程已经执行完毕。。。");
// System.out.println("继续执行主线程");
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
int N = 4;
CyclicBarrier barrier = new CyclicBarrier(N);
for (int i=0; i<N; i++){
new Writer(barrier).start();
}
int workNum = 8;//工人数目
Semaphore semaphore = new Semaphore(5);//信号量，机器数目
for (int i=0; i<workNum; i++){
new Worker(i,semaphore).start();
}
}
//用于栅栏
static class Writer extends Thread{
private CyclicBarrier cyclicBarrier;
public Writer(CyclicBarrier cyclicBarrier){
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run(){
System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据。。。");
try {
Thread.sleep(5000);
System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入数据。。。");
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println("所有线程写入数据完毕，继续执行其他任务。。。");
}
}
//用于信号量
static class Worker extends Thread{
private int num;
private Semaphore semaphore;
public Worker(int num, Semaphore semaphore){
this.num = num;
this.semaphore = semaphore;
}
@Override
public void run(){
try {
semaphore.acquire();
System.out.println("工人"+this.num+"占用一个机器生产。。。");
Thread.sleep(3000);
System.out.println("工人"+this.num+"释放出机器");
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
同步容器存在的问题：
如下代码所示：1.如果获取到lastSize之后有其他线程删除了vector中的元素，会发生ArrayIndexOutOfBoundsException异常需要手动加锁.
2.如果迭代过程中发生了修改，会发生并发修改异常，即java的快速失败机制。
例1：
Vector<Object> vector = new Vector<>();
int lastSize = vector.size()-1;
vector.remove(lastSize);
例2：
ArrayList<Object> list = new ArrayList<>();
list.add(1);
list.add(1);
list.add(1);
list.add(1);
list.add(1);
for (Object obj : list){
System.out.println(obj);
list.remove(obj);
}
并发容器说明：
1.
这个方法执行put的时候会做判断，如果没有才会执行put
ConcurrentHashMap map = new ConcurrentHashMap();
map.putIfAbsent(1,2);
2.
当有写操作的时候单独copy一份集合
CopyOnWriteArrayList/Set 应用场景：读操作多，写操作很少
3.阻塞队列，类似水管，先进先出
主要有put和take两个方法，如果队列中没有东西，执行take方法，那么就会阻塞等待执行了put方法之后才会继续执行take。
BlockingQueue
4.闭锁
CountDownLatch
线程1依赖线程2，当线程2执行完毕之后线程1才会继续执行，这种情况叫做闭锁，实例代码如下：
//第一个线程
new Thread(){
public void run(){
try {
System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
Thread.sleep(3000);
System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
//第二个线程
new Thread(){
public void run(){
try {
System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
Thread.sleep(3000);
System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
try {
System.out.println("等待两个子线程执行完毕。。。");
//闭锁
latch.await();
System.out.println("两个子线程已经执行完毕。。。");
System.out.println("继续执行主线程");
} catch (InterruptedException e) {
e.printStackTrace();
}
5.栅栏
要等待所有线程执行结束之后才能继续执行，类似一个team，要等待所有人搞定之后才能继续。
6.信号量
类似于工人和机器，比如说去上网有8个人5个机器，8个人都需要刷图，前五个人先使用机器，使用完一个释放出来一个，没使用过机器的补上，直到八个人都使用完毕。
