手写一个生产者消费，单例DCL，及一个ReentrantLock

生产者消费

public class Main {
    //容器
    private static List<String> list=new ArrayList<>();
    //容器的大小?阻塞队列？
    private static final int MAX=15;
    //定义一个锁
    private static Object lock=new Object();

    public static void main(String[] args) {
        Thread p1=new Thread(new ProductThread(5));
        Thread p2=new Thread(new ProductThread(5));
        Thread p3=new Thread(new ProductThread(5));
        Thread p4=new Thread(new ProductThread(5));

        Thread c1=new Thread(new ConsumerThread(10));
        Thread c2=new Thread(new ConsumerThread(10));


        p1.start();
        p2.start();
        p3.start();
        p4.start();
        c1.start();
        c2.start();
    }

    //定义一个生产者
    public static void product(int num){
        synchronized (lock){
            while(list.size()+num>MAX){
                try{
                    lock.wait();
                    System.out.println(Thread.currentThread().getName()+"----已经满了，不能继续生产");
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
            for (int i = 0; i < num; i++) {
                System.out.println(Thread.currentThread().getName()+"开始生产了");
                list.add(Thread.currentThread().getName()+":"+i);
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            lock.notifyAll();
        }
    }

    //定义一个消费者
    public static void consume(int num){
        synchronized (lock){
            while(list.size()<num){
                try{
                    lock.wait();
                    System.out.println(Thread.currentThread().getName()+"-----开始消费，已经空了，不能继续消费");
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
            for (int i = 0; i < num; i++) {
                System.out.println(Thread.currentThread().getName()+"开始消费了");
                System.out.println(Thread.currentThread().getName()+":"+list.remove(0));
            }
            lock.notifyAll();
        }
    }

    //定义一个生产者的静态类
    static class ProductThread implements Runnable{
        private int num;
        public ProductThread(int num){
            this.num=num;
        }
        public void run(){
            product(this.num);
        }
    }
    //定义一个消费者的静态类
    static class ConsumerThread implements Runnable{
        private int num;
        public ConsumerThread(int num){
            this.num=num;
        }
        public void run(){
            consume(this.num);
        }
    }
}

注意要有实例化对象

单例DCL

public class Singleton{
    //加volatile是为了防止指令重排
    private static volatile Singleton singleton;

    private Singleton(){};

    public static Singleton getInstance(){
        //外面判断一次是为了提高性能
        if(singleton==null){
            synchronized (singleton){
                //防止在多线程下的重复创建
                if(singleton==null){
                    singleton=new Singleton();
                }
            }
        }
        return singleton;
    }
}

注意看注释。

ReentrantLock条件输出

public class test1 {
    public static void main(String[] args) throws InterruptedException{
        AwaitSignal awaitSignal = new AwaitSignal(5);
        Condition a=awaitSignal.newCondition();
        Condition b=awaitSignal.newCondition();
        Condition c = awaitSignal.newCondition();

        new Thread(() ->{
            awaitSignal.print("a",a,b);
        },"t1").start();
        new Thread(() ->{
            awaitSignal.print("b",b,c);
        },"t2").start();
        new Thread(() ->{
            awaitSignal.print("c",c,a);
        },"t3").start();

        Thread.sleep(1000);

        awaitSignal.lock();
        try{
            System.out.println("开始。。。。");
            a.signal();
        }finally {
            awaitSignal.unlock();
        }
    }

}
class AwaitSignal extends ReentrantLock {

    //循环次数
    private int loopNumber;

    public AwaitSignal(int loopNumber) {
        this.loopNumber = loopNumber;
    }

    //打印内容,进入哪些休息室
    public void print(String str, Condition room, Condition nextRoom) {
        for (int i = 0; i < loopNumber; i++) {
            lock();
            try {
                room.await();
                System.out.println(str);
                nextRoom.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                unlock();
            }
        }
    }
}