【进击面试_02】Java 多线程

public class Test {
    public static void main(String[] args) {
        // 创建自定义线程对象
        MyThread mt = new MyThread();
        // 开启新线程
        mt.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("main 线程 正在执行: " + i);
        }
    }
}

class MyThread extends Thread {
    /**
     * 重写run方法，完成该线程执行的逻辑
     * 该 run( ) 方法的方法体就代表了线程需要完成的任务,因此把 run( ) 方法称为线程执行体。
     */
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("MyThread 线程 正在执行: " + i);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        // 通过匿名内部类创建 Runnable 实现类对象
        Runnable myRunnable = new Runnable() {
		    @Override
		    public void run() {
		        for (int i = 0; i < 100; i++) {
		            System.out.println(Thread.currentThread().getName() + " 正在执行: " + i);
		        }
		    }
		};

		// 通过 MyRunnable 创建线程
        Thread thread = new Thread(myRunnable);
        thread.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("main 线程 正在执行: " + i);
        }
    }
}

public class Test {

    public static void main(String[] args) {

        // 创建 Callable 匿名内部类对象
        Callable<String> callable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName() + "---" + i);
                }
                return "我执行完了";
            }
        };

        // 使用 FutureTask 来包装 Callable
        FutureTask<String> futureTask = new FutureTask<>(callable);

        // 通过 FutureTask 创建线程
        Thread thread = new Thread(futureTask, "我是通过 Callable 接口创建的线程");
        thread.start();

        try {
            // 打印线程返回值
            System.out.println(futureTask.get());
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

/**
 * @author Demo_Null
 * @version 1.0
 * @date 2021/2/26
 * @desc 资源类
 */
public class MyData {
    private Integer num = 0;
    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void add() {
        lock.lock();
        try {
            // 使用 while 避免虚假唤醒
            while (0 != num) {
                // 不为 0, 等待 sub
                condition.await();
            }

            // 生产
            num++;
            System.out.println(Thread.currentThread().getName() + " 修改 num = " + num);

            // 唤醒 sub
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void sub() {
        lock.lock();
        try {
            // 使用 while 避免虚假唤醒
            while (0 == num) {
                // 不为 0, 等待 add
                condition.await();
            }

            // 消费
            num--;
            System.out.println(Thread.currentThread().getName() + " 修改 num = " + num);

            // 唤醒 sub
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}

/**
 * @author Demo_Null
 * @version 1.0
 * @date 2021/2/26
 * @desc 两线程操作 num, 一增一减交替执行
 */
public class BlockingQueueDemo {

    public static void main(String[] args) {
        MyData myData = new MyData();

        new Thread(() -> {
            for (int i = 0; i < 6; i++) {
                myData.add();
            }
        }, "A").start();


        new Thread(() -> {
            for (int i = 0; i < 6; i++) {
                myData.sub();
            }
        }, "B").start();
    }
}

/**
 * @author Demo_Null
 * @version 1.0
 * @date 2021/2/26
 * @desc 资源类
 */
public class MyData {
    private AtomicInteger atomicInteger = new AtomicInteger();
    BlockingQueue<Integer> blockingQueue = null;

    public MyData(BlockingQueue<Integer> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    public void add() {

        try {
            // 产生数据
            int i = new Random().nextInt(100);
            // 加 synchronized 是为了保证下面代码不被加塞
            synchronized (this) {
                // 加入队列
                boolean offer = blockingQueue.offer(i, 2L, TimeUnit.SECONDS);
                String name = Thread.currentThread().getName();
                System.out.println((offer ? i : "阻塞") + " >>> " + name + "\t" +blockingQueue);
            }

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void sub() {
        try {
            // 加 synchronized 是为了保证下面代码不被加塞
            synchronized (this) {
                Integer poll = blockingQueue.poll(2L, TimeUnit.SECONDS);
                String name = Thread.currentThread().getName();
                System.out.println((null == poll ? "阻塞" : poll) + " <<< " + name + "\t" +blockingQueue);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/**
 * @author Demo_Null
 * @version 1.0
 * @date 2021/2/26
 * @desc 模拟消息队列
 */
public class BlockingQueueDemo {

    public static void main(String[] args) {
        MyData myData = new MyData(new ArrayBlockingQueue<>(2));

                for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                for (int j = 0; j < 2; j++) {
                    myData.add();
                    try { Thread.sleep(100); } catch (Exception e) { e.printStackTrace(); }
                }
            }, "A-" + i).start();
            try { Thread.sleep(100); } catch (Exception e) { e.printStackTrace(); }
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        new Thread(() -> {
            for (int j = 0; j < 6; j++) {
                myData.sub();
                try { Thread.sleep(100); } catch (Exception e) { e.printStackTrace(); }
            }
        }, "B-0").start();

    }
}

/**
 * @author Demo_Null
 * @version 1.0
 * @date 2021/2/26
 * @desc 自定义线程池
 */
public class ThreadPoolDemo {

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2,
                5,
                1L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        try {
        	// 最大支持 maximumPoolSize 加 阻塞队列大小，超过则使用拒绝策略
            for (int i = 0; i < 8; i++) {
                threadPoolExecutor.execute(() -> {
                    System.out.println(Thread.currentThread().getName());
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPoolExecutor.shutdown();
        }
    }
}

/**
 * @author Demo_Null
 * @version 1.0
 * @date 2021/2/26
 * @desc //TODO
 */
public class MyThread implements Runnable {
    private String lockA;
    private String lockB;

    public MyThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA) {
            System.out.println(Thread.currentThread().getName() + " 已有 " + lockA + " 尝试获取 " + lockB);

            synchronized (lockB) {
                System.out.println(Thread.currentThread().getName() + " 已有 " + lockB + " 尝试获取 " + lockA);
            }
        }
    }
}

/**
 * @author Demo_Null
 * @version 1.0
 * @date 2021/2/26
 * @desc 死锁
 */
public class DeadLockDemo {

    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";

        new Thread(new MyThread(lockA, lockB), "A").start();
        new Thread(new MyThread(lockB, lockA), "B").start();

    }
}