三个线程轮流打印ABC

线程的创建

package JUC.juc1;

public class CreateThread {
    public static void main(String[] args) {
        ThreadDemo1 threadDemo1 = new ThreadDemo1();
        threadDemo1.setName("Thread Method");
        threadDemo1.start();

        Thread runnable = new Thread(new ThreadDemo2(), "Runnable interface");
        runnable.start();
        // 直接调用run方法的话，是主线程（main）执行run方法
        runnable.run();

        new Thread(
                () -> 
                System.out.println(Thread.currentThread() + "run3()方法执行"), "run3")
                .start();
    }
}

// 1. 继承Thread方法
class ThreadDemo1 extends Thread {

    @Override
    public void run() {
        System.out.println(Thread.currentThread() + "run1()方法执行");
    }
}

// 2. 实现Runnable接口
class ThreadDemo2 implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread() + "run2()方法执行");
    }
}

死锁

package JUC.juc1;

/**
 * 死锁
 *
 * 解决方法：资源需要按照顺序来获取，两个线程都需要先获取资源1，再获取资源2.
 */
public class DeadLockDemo {

    private static Object resource1 = new Object();
    private static Object resource2 = new Object();

    public static void main(String[] args) {

        new Thread(() -> {
            synchronized (resource1){
                System.out.println(Thread.currentThread() + "get resource1");
                try {
                    // 等待1秒，让两个线程各自拿到资源。
                    Thread.sleep(1000);
                } catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + "waiting get resource2");

                synchronized (resource2){
                    System.out.println(Thread.currentThread() + "get resource2");
                }
            }
        }, "线程1").start();

        Thread thread = new Thread(new Thread2(), "线程2");
        thread.start();

    }

    static class Thread2 implements Runnable{

        @Override
        public void run() {

            // 同步代码块
            synchronized (resource2) {
                System.out.println(Thread.currentThread() + "get resource2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e){
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread() + "waiting get resource1");
                synchronized (resource1) {
                    System.out.println(Thread.currentThread() + "get resource1");
                }
            }

        }
    }
}

三个线程轮流打印ABC

package JUC.juc1;

public class PrintABC {

    // 条件变量
    private int num;
    // 锁
    private static final Object Lock = new Object();

    public static void main(String[] args) {

        PrintABC printABC = new PrintABC();
        // 轮流打印50次
        for (int i =0; i < 50; i++){
            // 线程1
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    printABC.printMehthod("A", 0);
                }
            });
            thread1.setName("A");
            thread1.start();
            // 线程2
            new Thread(new Runnable() {
                @Override
                public void run() {
                    printABC.printMehthod("B", 1);
                }
            }, "B").start();
            // 线程3
            new Thread(() -> printABC.printMehthod("C", 2), "C").start();
        }
        Lock.notifyAll();
    }
	
    /**
    name: ABC
    targetNum:0,1,2
    */
    private void printMehthod(String name, int targetNum){
        synchronized (Lock)
        {
            while (num % 3 != targetNum) {
                try {
                    Lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            num++;
            System.out.println(name);
            Lock.notifyAll();
        }
    }
}

// A
// B
// C
// A
// B
// C

两个线程轮流打印奇偶数

package JUC.juc1;

public class PrintOddEven {
    // 条件变量
    private volatile int count;
    // 锁
    private Object monitor = new Object();

    PrintOddEven(int initCount){
        this.count = initCount;
    }

    public static void main(String[] args) {
        PrintOddEven printOddEven = new PrintOddEven(0);
        new Thread(() -> printOddEven.printMethod(), "odd ").start();
        new Thread(() -> printOddEven.printMethod(), "even").start();
    }

    private void printMethod() {
        synchronized (monitor)
        {
            while (count < 100) {
                try {
                    System.out.print(Thread.currentThread().getName() + ":");
                    System.out.println(++count);
                    monitor.notifyAll();
                    monitor.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 防止 while 退出循环后，还有线程被阻塞为唤醒，导致主线程无法退出
            monitor.notifyAll();
        }
    }
}

// odd :1
// even:2
// odd :3
// even:4
// odd :5
// even:6
// odd :7
// even:8

N个线程轮流连续打印1到100.

package JUC.juc1;

/**
 * N个线程轮流打印1到100
 */
public class PrintOneByOneTo100 {

    private volatile int num = 0;
    private static int N = 4;
    private int maxnum = 100;
    private Object monitor = new Object();

    public static void main(String[] args) {
        PrintOneByOneTo100 printOneByOneTo100 = new PrintOneByOneTo100();
        for (int i = 0; i < N; i++){
            int finalI = i;
            new Thread(() -> printOneByOneTo100.printMethod(finalI), "Thread" + i).start();
        }
    }
    private void printMethod(int targetNum) {
        while (true) {
            synchronized (monitor) {
                while (num % N != targetNum) {
                    if (num >=  maxnum){
                        break;
                    }
                    try {
                        monitor.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if (num >= maxnum) {
                    break;
                }
                num++;
                System.out.println(Thread.currentThread() + ":" + num);
                monitor.notifyAll();
            }
        }
    }
}

// Thread[Thread0,5,main]:1
// Thread[Thread1,5,main]:2
// Thread[Thread2,5,main]:3
// Thread[Thread3,5,main]:4
// Thread[Thread0,5,main]:5
// Thread[Thread1,5,main]:6
// Thread[Thread2,5,main]:7
// Thread[Thread3,5,main]:8
// Thread[Thread0,5,main]:9