Java多线程实现交替打印数字和字母的n种方式

package com.lutongnet.util;

import org.junit.Test;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.TransferQueue;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author mifei
 * @version 1.0.0
 * @description 多线程测试
 * @date 2020-11-28 15:18
 */
public class CommonThreadTest {

    Thread t1 = null;
    Thread t2 = null;

    /**
     * 测试Synchronized的wait和notify写法
     */
    @Test
    public void testSynchronized() {
        Object o = new Object();
        char [] letterArray = "ABCDEFGHIJ".toCharArray();
        char [] numbberArray = "1234567890".toCharArray();

        t1 = new Thread(()->{
            synchronized (o) {
                for (char c: letterArray) {
                    System.out.println("字母：" + c);
                    try {
                        o.notify();
                        o.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                o.notify();
            }
        });

        t2 = new Thread(()->{
            synchronized (o) {
                for (char c: numbberArray) {
                    System.out.println("数字：" + c);
                    try {
                        o.notify();
                        o.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                o.notify();
            }
        });

        t1.start();
        t2.start();
    }

    /**
     * 测试ReenTrantLock写法
     */
    @Test
    public void testReenTrantlock() {
        char [] letterArray = "ABCDEFGHIJ".toCharArray();
        char [] numberArray = "1234567890".toCharArray();

        Lock lock = new ReentrantLock();
        Condition letterCondition = lock.newCondition();
        Condition numberCondition = lock.newCondition();

        new Thread(()->{
            try {
                lock.lock();
                for (char c: letterArray) {
                    System.out.println("字母：" + c);
                    numberCondition.signal();
                    letterCondition.await();
                }
                numberCondition.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }, "t1").start();

        new Thread(()->{
            try {
                lock.lock();
                for (char c: numberArray) {
                    System.out.println("数字：" + c);
                    letterCondition.signal();
                    numberCondition.await();
                }
                letterCondition.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }, "t2").start();
    }

    /**
     * 测试LockSupport写法
     */
    @Test
    public void testLockSupport() {
        char [] letterArray = "ABCDEFGHIJ".toCharArray();
        char [] numberArray = "1234567890".toCharArray();

        t1 = new Thread(()->{
            for (char c: letterArray) {
                System.out.println("字母：" + c);
                LockSupport.unpark(t2);
                LockSupport.park();
            }
        });

        t2 = new Thread(()->{
            for (char c: numberArray) {
                LockSupport.park();
                System.out.println("数字：" + c);
                LockSupport.unpark(t1);
            }
        });

        t1.start();
        t2.start();
    }

    /**
     * 测试BlockingQueue写法
     */
    @Test
    public void testBlockingQueue() {
        char [] letterArray = "ABCDEFGHIJ".toCharArray();
        char [] numberArray = "1234567890".toCharArray();

        BlockingQueue<String> q1 = new ArrayBlockingQueue(1);
        BlockingQueue<String> q2 = new ArrayBlockingQueue(1);

        new Thread(()->{
            for (char c: letterArray) {
                System.out.println("字母：" + c);
                try {
                    q1.put("ok");
                    q2.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "t1").start();

        new Thread(()->{
            for (char c: numberArray) {
                try {
                    q1.take();
                    System.out.println("数字：" + c);
                    q2.put("ok");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t2").start();
    }

    /**
     * 测试AtomicInteger写法
     */
    @Test
    public void testAtomicInteger() {
        AtomicInteger threadNo = new AtomicInteger(1);

        char [] letterArray = "ABCDEFGHIJ".toCharArray();
        char [] numberArray = "1234567890".toCharArray();

        new Thread(()->{
            for (char c: letterArray) {
                while (threadNo.get() != 1) {}
                System.out.println("字母：" + c);
                threadNo.set(2);
            }
        }, "t1").start();

        new Thread(()->{
            for (char c: numberArray) {
                while (threadNo.get() != 2) {}
                System.out.println("数字：" + c);
                threadNo.set(1);
            }
        }, "t2").start();
    }

    /**
     * 测试TransferQueue写法
     */
    @Test
    public void testTransferQueue() {
        char [] letterArray = "ABCDEFGHIJ".toCharArray();
        char [] numberArray = "1234567890".toCharArray();

        TransferQueue<Character> queue = new LinkedTransferQueue<>();
        new Thread(()->{
            try {
                for (char c : letterArray) {
                    System.out.println("数字：" + queue.take());
                    queue.transfer(c);
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t1").start();

        new Thread(()->{
            try {
                for (char c : numberArray) {
                    queue.transfer(c);
                    System.out.println("字母：" + queue.take());
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t2").start();

    }
}