Thread--两线程交替打印

package t3.copy;

public class ThreadA extends Thread {
    
    private Object lock;

    public ThreadA(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            while(true) {
                synchronized (lock) {
                    if(Run.flag) {
                        System.out.println(Thread.currentThread().getName() + " ~~~~ ");
                        Run.flag = !Run.flag;
                        lock.wait();
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    

}

package t3.copy;

public class ThreadB extends Thread {
    
    private Object lock;

    public ThreadB(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            while(true) {
                synchronized (lock) {
                    if(!Run.flag) {
                        System.out.println(Thread.currentThread().getName() + " !!!! ");
                        Run.flag = !Run.flag;
                        lock.notify();
                    }
                }
                
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    

}

package t3.copy;

public class Run {
    
    public static boolean flag = true;
    
    public static void main(String[] args) {
        try {
            Object lock = new Object();
            ThreadA a = new ThreadA(lock);
            a.start();
            Thread.sleep(50);
            ThreadB b = new ThreadB(lock);
            b.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

不知道可不可以不借助于中间变量判断。

不借助于中间变量判断，但是交替打印次数一致。

package conditionTest.copy;

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

public class MyService {
    
    private ReentrantLock lock = new ReentrantLock();
    private Condition conditionSet = lock.newCondition();
    private Condition conditionGet = lock.newCondition();
    
    public void set() {
        try {
            lock.lock();
//            while(hasValue) {
//            }
            System.out.println("打印★★★★★★");
            conditionGet.signal();
            conditionSet.await();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    
    public void get() {
        try {
            lock.lock();
            System.out.println("打印☆☆☆☆☆☆");
            conditionSet.signal();
            conditionGet.await();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

package conditionTest.copy;

public class MyThreadA extends Thread {
    
    private MyService service;

    public MyThreadA(MyService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            service.set();
        }
    }
    
    

}

package conditionTest.copy;

public class MyThreadB extends Thread {
    
    private MyService service;

    public MyThreadB(MyService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            service.get();
        }
    }
    
    

}

package conditionTest.copy;

public class Run {
    
    public static void main(String[] args) {
        MyService service = new MyService();
        MyThreadA a = new MyThreadA(service);
        a.start();
        MyThreadB b = new MyThreadB(service);
        b.start();
    }

}