两个线程交叉打印1-100

public class printOneToHundred {
    private static volatile boolean state = true;
    private static volatile int count = 1;
    private static final Object lock = new Object();

    class Producer1 extends Thread {
        @Override
        public void run() {
            while (count < 100) {
                synchronized (lock) {
                    while (!state) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("线程1打印：" + count);
                    count++;
                    state = false;
                    lock.notify();
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    class Producer2 extends Thread {
        @Override
        public void run() {
            while (count < 100) {
                synchronized (lock) {
                    while (state) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("线程2打印：" + count);
                    count++;
                    state = true;
                    lock.notify();
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        printOneToHundred print = new printOneToHundred();
        Producer1 p = print.new Producer1();
        Producer2 c = print.new Producer2();
        p.start();
        c.start();
    }
}

循环打印ABC

volatile实现

public class VolatileOrderThread {

    static volatile int ticket = 1;

    public static void main(String[] args) {

        Thread thread1 = new Thread(() -> {
            while (true) {
                if (ticket == 1) {
                    System.out.println("A");
                    ticket = 2;
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            while (true) {
                if (ticket == 2) {
                    System.out.println("B");
                    ticket = 3;
                }
            }
        });

        Thread thread3 = new Thread(() -> {
            while (true) {
                if (ticket == 3) {
                    System.out.println("C");
                    ticket = 1;
                }
            }
        });

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

ReentrantLock实现

public class PrintABC {
    // 共享变量，表示当前应该打印哪个字母
    private static int state = 0;
    private static ReentrantLock lock = new ReentrantLock();
    private static final Condition A = lock.newCondition();
    private static final Condition B = lock.newCondition();
    private static final Condition C = lock.newCondition();

    public static void main(String[] args) {
        Thread threadA = new Thread(()->{
            try {
                for(int i=0;i<100;i++){
                    lock.lock();
                    try {
                        while(state%3!=0)
                            A.await();
                        System.out.println("A");
                        state++; // 状态修改
                        B.signal();// 唤醒下一个线程
                    } finally {
                        lock.unlock();
                    }
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        Thread threadB = new Thread(()->{
            try {
                for(int i=0;i<100;i++){
                    lock.lock();
                    try {
                        while(state%3!=1)
                            B.await();
                        System.out.println("B");
                        state++; // 状态修改
                        C.signal();// 唤醒下一个线程
                    } finally {
                        lock.unlock();
                    }
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        Thread threadC = new Thread(()->{
            try {
                for(int i=0;i<100;i++){
                    lock.lock();
                    try {
                        while(state%3!=2)
                            C.await();
                        System.out.println("C");
                        state++; // 状态修改
                        A.signal();// 唤醒下一个线程
                    } finally {
                        lock.unlock();
                    }
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        threadA.start();
        threadB.start();
        threadC.start();
    }

}

Semaphore实现

public class PrintABC2 {
    // 三个信号量对象，分别表示A、B、C三个线程的初始许可数
    private static Semaphore A = new Semaphore(1);
    private static Semaphore B = new Semaphore(0);
    private static Semaphore C = new Semaphore(0);

    public static void main(String[] args) {
        Thread threadA = new Thread(()->{
            try {
                for(int i=0;i<100;i++){
                    A.acquire();
                    System.out.println("A");
                    B.release();
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        Thread threadB = new Thread(()->{
            try {
                for(int i=0;i<100;i++){
                    B.acquire();
                    System.out.println("B");
                    C.release();
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        Thread threadC = new Thread(()->{
            try {
                for(int i=0;i<100;i++){
                    C.acquire();
                    System.out.println("C");
                    A.release();
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        threadA.start();
        threadB.start();
        threadC.start();
    }
}

多线程任务调度

优先级队列+Runnable；

public class Task implements Comparable<Task> {

    private int priority;
    private Runnable runnable;

    public Task(int priority, Runnable runnable) {
        this.priority = priority;
        this.runnable = runnable;
    }

    public void run() {
        runnable.run();
    }

    @Override
    public int compareTo(Task o) {
        return Integer.compare(priority, o.priority);
    }

}

public class MyTaskScheduler {

    private PriorityQueue<Task> queue;

    public MyTaskScheduler() {
        queue = new PriorityQueue<>();
    }

    public void schedule(Task task) {
        queue.offer(task);
    }

    public void run() {
        while (!queue.isEmpty()) {
            Task task = queue.poll();
            task.run();
        }
    }

}