JUC并发编程(10.Java线程）

痛定思痛。 2023-09-24 19:03 23阅读 0赞

# 1.同步模式之顺序控制 #

## synchronized (lock) ##

public class Test25 {
        
        static final Object lock = new Object();
        // 表示 t2 是否运行过
        static boolean t2runned = false;
    
        public static void main(String[] args) {
        
            Thread t1 = new Thread(() -> {
        
                synchronized (lock) {
        
                    while (!t2runned) {
        
                        try {
        
                            lock.wait();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    log.debug("1");
                }
            }, "t1");
    
    
            Thread t2 = new Thread(() -> {
        
                synchronized (lock) {
        
                    log.debug("2");
                    t2runned = true;
                    lock.notify();
                }
            }, "t2");
    
            t1.start();
            t2.start();
        }
    }

09:13:34.577 c.Test25 [t2] - 2
    09:13:34.579 c.Test25 [t1] - 1

## park，unpark ##

public class Test26 {
        
        public static void main(String[] args) {
        
    
            Thread t1 = new Thread(() -> {
        
                LockSupport.park();
                log.debug("1");
            }, "t1");
            t1.start();
    
            new Thread(() -> {
        
                log.debug("2");
                LockSupport.unpark(t1);
            },"t2").start();
        }
    }

09:15:21.180 c.Test26 [t2] - 2
    09:15:21.182 c.Test26 [t1] - 1

## 交替输出 ##

![在这里插入图片描述][5bc34a2f2d504de5ae83f24f82914ba1.png]

### notify ###

public class Test27 {
        
        public static void main(String[] args) {
        
            WaitNotify wn = new WaitNotify(1, 5);
            new Thread(() -> {
        
                wn.print("a", 1, 2);
            }).start();
            new Thread(() -> {
        
                wn.print("b", 2, 3);
            }).start();
            new Thread(() -> {
        
                wn.print("c", 3, 1);
            }).start();
        }
    }
    
    /*
    输出内容       等待标记     下一个标记
       a           1             2
       b           2             3
       c           3             1
     */
    class WaitNotify {
        
        // 打印               a           1             2
        public void print(String str, int waitFlag, int nextFlag) {
        
            for (int i = 0; i < loopNumber; i++) {
        
                synchronized (this) {
        
                    while(flag != waitFlag) {
        
                        try {
        
                            this.wait();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    System.out.print(str);
                    flag = nextFlag;
                    this.notifyAll();
                }
            }
        }
    
        // 等待标记
        private int flag; // 2
        // 循环次数
        private int loopNumber;
    
        public WaitNotify(int flag, int loopNumber) {
        
            this.flag = flag;
            this.loopNumber = loopNumber;
        }
    }

abcabcabcabcabc

### ReenTrantLock ###

public class Test30 {
        
        public static void main(String[] args) throws InterruptedException {
        
            AwaitSignal awaitSignal = new AwaitSignal(5);
            Condition a = awaitSignal.newCondition();
            Condition b = awaitSignal.newCondition();
            Condition c = awaitSignal.newCondition();
            new Thread(() -> {
        
                awaitSignal.print("a", a, b);
            }).start();
            new Thread(() -> {
        
                awaitSignal.print("b", b, c);
            }).start();
            new Thread(() -> {
        
                awaitSignal.print("c", c, a);
            }).start();
    
            Thread.sleep(1000);
            awaitSignal.lock();
            try {
        
                System.out.println("开始...");
                a.signal();
            } finally {
        
                awaitSignal.unlock();
            }
    
        }
    }
    
    class AwaitSignal extends ReentrantLock{
        
        private int loopNumber;
    
        public AwaitSignal(int loopNumber) {
        
            this.loopNumber = loopNumber;
        }
        //            参数1 打印内容， 参数2 进入哪一间休息室, 参数3 下一间休息室
        public void print(String str, Condition current, Condition next) {
        
            for (int i = 0; i < loopNumber; i++) {
        
                lock();
                try {
        
                    current.await();
                    System.out.print(str);
                    next.signal();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                } finally {
        
                    unlock();
                }
            }
        }
    }

abcabcabcabcabc

### Park&& unpark ###

ublic class Test31 {
        
    
        static Thread t1;
        static Thread t2;
        static Thread t3;
        public static void main(String[] args) {
        
            ParkUnpark pu = new ParkUnpark(5);
            t1 = new Thread(() -> {
        
                pu.print("a", t2);
            });
            t2 = new Thread(() -> {
        
                pu.print("b", t3);
            });
            t3 = new Thread(() -> {
        
                pu.print("c", t1);
            });
            t1.start();
            t2.start();
            t3.start();
    
            LockSupport.unpark(t1);
        }
    }
    
    class ParkUnpark {
        
        public void print(String str, Thread next) {
        
            for (int i = 0; i < loopNumber; i++) {
        
                LockSupport.park();
                System.out.print(str);
                LockSupport.unpark(next);
            }
        }
    
        private int loopNumber;
    
        public ParkUnpark(int loopNumber) {
        
            this.loopNumber = loopNumber;
        }
    }

abcabcabcabcabc

# 2. 本章小结 #

本章我们需要重点掌握的是

*  分析多线程访问共享资源时，哪些代码片段属于临界区
 *  使用 synchronized 互斥解决临界区的线程安全问题
    
     *  掌握 synchronized 锁对象语法
     *  掌握 synchronzied 加载成员方法和静态方法语法
     *  掌握 wait/notify 同步方法
 *  使用 lock 互斥解决临界区的线程安全问题
    
     *  掌握 lock 的使用细节：可打断、锁超时、公平锁、条件变量
 *  学会分析变量的线程安全性、掌握常见线程安全类的使用
 *  了解线程活跃性问题：死锁、活锁、饥饿

应用方面

*  互斥：使用 synchronized 或 Lock 达到共享资源互斥效果
 *  同步：使用 wait/notify 或 Lock 的条件变量来达到线程间通信效果

原理方面

*  monitor、synchronized 、wait/notify 原理
 *  synchronized 进阶原理
 *  park & unpark 原理

模式方面

*  同步模式之保护性暂停
 *  异步模式之生产者消费者
 *  同步模式之顺序控制

[5bc34a2f2d504de5ae83f24f82914ba1.png]: https://img-blog.csdnimg.cn/5bc34a2f2d504de5ae83f24f82914ba1.png