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();
    }
}