[笔记]Java狂神说JUC并发教程

package duoxiancheng.bao;
/*
 * 虚假唤醒的解决：
 *  wait要始终保证在while循环当中。
 */
public class LockTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producter producter = new Producter(clerk);
        Customer customer = new Customer(clerk);
        new Thread(producter,"生产者A").start();
        new Thread(customer,"消费者A").start();
        new Thread(producter,"生产者B").start();
        new Thread(customer,"消费者B").start();
    }
}
// 售货员
class Clerk {
    private int product = 0;
    // 进货
    public synchronized void add() {
        // 产品已满
        while (product >=1) {
            System.out.println(Thread.currentThread().getName() + ": " + "已满！");
            try {
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        ++product;
        // 该线程从while中出来的时候，是满足条件的
        System.out.println(Thread.currentThread().getName() + ": " +"....................进货成功，剩下"+product);
        this.notifyAll();
    }
    // 卖货
    public synchronized void sale() {
        while (product <=0) {
            System.out.println(Thread.currentThread().getName() + ": " + "没有买到货");
            try {
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        --product;
        System.out.println(Thread.currentThread().getName() + ":买到了货物，剩下 " + product);
        this.notifyAll();
    }
}
// 生产者
class Producter implements Runnable {
    private Clerk clerk;
    public Producter(Clerk clerk) {
        this.clerk = clerk;
    }
    // 进货
    @Override
    public void run() {
        for(int i = 0; i < 20; ++i) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
            }
            clerk.add();
        }
    }
}
// 消费者
class Customer implements Runnable {
    private Clerk clerk;
    public Customer(Clerk clerk) {
        this.clerk = clerk;
    }
    // 买货
    @Override
    public void run() {
        for(int i = 0; i < 20; ++i) {
            clerk.sale();
        }
    }
}

package com.kuang.callable;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.locks.ReentrantLock;
/**
* 1、探究原理
* 2、觉自己会用
*/
public class CallableTest {
public static void main(String[] args) throws ExecutionException,InterruptedException {
        // new Thread(new Runnable()).start();
        // new Thread(new FutureTask<V>()).start();
        // new Thread(new FutureTask<V>( Callable )).start();
        new Thread().start(); // 怎么启动Callable
        MyThread thread = new MyThread();
        FutureTask futureTask = new FutureTask(thread); // 适配类
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start(); // 结果会被缓存，效率高
        Integer o = (Integer) futureTask.get(); //这个get 方法可能会产生阻塞！把他放到
        最后
        // 或者使用异步通信来处理！
        System.out.println(o);
    }
}
class MyThread implements Callable<Integer> {
    @Override
    public Integer call() {
        System.out.println("call()"); // 会打印几个call
        // 耗时的操作
        return 1024;
    }
}

CountDownLatch coutnDownLatch = new CoutDownLatch(6);//减法计数器
for(int i=1;i<=6;i++){
    new Thread(()->{
        System.out.println(Thread.currentThread().getName + "go out");
        coutDownLatch.countDown();//计数器-1
    },String.valueof(i)).start();
}
coutDownLatch.await();//等待计数器归零
System.out.println("Close the Door!");

//集齐七颗龙珠召唤神龙。
CyclicBarrier cyclicbarrier = new CyclicBarrier(7,()->{
    System.out.println("召唤神龙成功！");
});
for(int i=1;i<=7;i++){
    new Thread(()->{
        System.out.println("收集了"+i+"颗龙珠");
    },String.valueof(i)).start();
}
cyclicBarrier.await();//等待计数器变成7时

//acquire() 得到
//release() 释放
package com.kuang.add;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
public class SemaphoreDemo {
    public static void main(String[] args) {
        // 线程数量：停车位! 限流！
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <=6 ; i++) {
            new Thread(()->{
                // acquire() 得到
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"抢到车
                    位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开车
                    位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release(); // release() 释放
                }
            },String.valueOf(i)).start();
        }
    }
}

 class FillAndEmpty {
   Exchanger<DataBuffer> exchanger = new Exchanger<>();
   
   //下面是两个装数据的实体类
   DataBuffer initialEmptyBuffer = ... a made-up type
   DataBuffer initialFullBuffer = ...
	
   //FillingLoop ： 不断向DataBuffer中添加数据，并交换给EmptyingLoop
   class FillingLoop implements Runnable {
     public void run() {
       DataBuffer currentBuffer = initialEmptyBuffer;
       try {
         while (currentBuffer != null) {
           addToBuffer(currentBuffer);//从currentBuffer里取出一个数据
           if (currentBuffer.isFull()){
               //如果是装满了，就交还给EmptyingLoop类进行消费
	           currentBuffer = exchanger.exchange(currentBuffer);
           }
         }
       } catch (InterruptedException ex) { ... handle ... }
     }
   }

   //EmptyingLoop ： 不断从DataBuffer中取出数据，并交换给FillingLoop
   class EmptyingLoop implements Runnable {
     public void run() {
       DataBuffer currentBuffer = initialFullBuffer;
       try {
         while (currentBuffer != null) {
           takeFromBuffer(currentBuffer);
           if (currentBuffer.isEmpty()){
               //如果消费完了，则交换buffer给FillingLoop进行生产
             currentBuffer = exchanger.exchange(currentBuffer);
           }
         }
       } catch (InterruptedException ex) { ... handle ...}
     }
   }
   
   void takeFromBuffer(DataBuffer dataBuffer){
       //.....
       dataBuffer.take();
       //......
   }
   void addToBuffer(DataBuffer dataBuffer){
       //.....
       dataBuffer.add(xxxxx);
       //......
   }
   void start() {
     new Thread(new FillingLoop()).start();
     new Thread(new EmptyingLoop()).start();
   }
 }