java多线程Lock synchronized Callable 生产者消费者

只是个人的一个示例，怕忘，记录一下。要弄清锁的到底是什么东东，一般就是锁的对象（具体的实例对象，对同一个对象操作才需要锁）

Callable纯属自己瞎玩，实在不知道生产都消费者用这个接口怎么玩。

JucLock.java

通过Lock 和 Condition实现ABCD 4个线程按顺序执行，实现生产者消费者功能 

package juc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class JucLock {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i = 0; i <20 ; i++) {
                try {
                    data.add();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(()->{
            for (int i = 0; i <20 ; i++) {
                try {
                    data.addx();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(()->{
            for (int i = 0; i <20 ; i++) {
                try {
                    data.minus();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(()->{
            for (int i = 0; i <20 ; i++) {
                try {
                    data.minusx();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

class Data {
    int num =0;
    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    Condition condition4 = lock.newCondition();
    public void add() throws InterruptedException {
        lock.lock();
        while(num>0)
        {
            condition1.await();
        }
        num++;
        System.out.println(Thread.currentThread().getName() + " A " + num);
        condition2.signal();
        lock.unlock();
    }
    public void minus() throws InterruptedException {
        lock.lock();
        while(num<=0)
        {
            condition2.await();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + " B " + num);
        condition3.signal();
        lock.unlock();
    }
    public void addx() throws InterruptedException {
        lock.lock();
        while(num>0)
        {
            condition3.await();
        }
        num++;
        System.out.println(Thread.currentThread().getName() + " C " + num);
        condition4.signal();
        lock.unlock();
    }
    public void minusx() throws InterruptedException {
        lock.lock();
        while(num<=0)
        {
            condition4.await();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + " D " + num);
        condition1.signal();
        lock.unlock();
    }
}
           

 JucCallable.java

主要是通过Callable接口实现生产者消费者功能

package juc;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class JucCallable {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Datax d = new Datax();

        FutureTask ftadd = new FutureTask(new AddThread(d));
        FutureTask ftminus = new FutureTask(new MinusThread(d));
        FutureTask ftadd2 = new FutureTask(new AddThread(d));
        FutureTask ftminus2 = new FutureTask(new MinusThread(d));
        //for (int i = 1; i < 10; i++) {
            new Thread(ftadd).start();
            new Thread(ftminus).start();
            new Thread(ftadd2).start();
            new Thread(ftminus2).start();
        //}

    }

}

class AddThread implements Callable<Datax>{
    private Datax d;
    AddThread(Datax d){
        this.d =d;
    }
    @Override
    public Datax call() throws Exception {
        for (int i = 0; i < 10; i++) {
            d.add();
        }
        return d;
    }
}
class MinusThread implements Callable<Datax>{
    private Datax d;
    MinusThread(Datax d){
        this.d =d;
    }
    @Override
    public Datax call() throws Exception {
        for (int i = 0; i < 10; i++) {
            d.minus();
        }
        return d;
    }
}
class Datax {
    private int num=0;

    public synchronized void add() throws InterruptedException {
        while(num>0)
        {
            this.wait();
            System.out.println(">0 wait");
        }
        num++;
        System.out.println(num + "waked ++");
        this.notifyAll();
    }
    public synchronized void minus() throws InterruptedException {
        while(num<=0)
        {
            this.wait();
            System.out.println("<=0 wait");
        }
        num--;
        System.out.println(num + "waked --");
        this.notifyAll();
    }
}