025-day24-多线程1

24.01_多线程(多线程的引入)(了解)

  • 1.什么是线程
  • 线程是程序执行的一条路径, 一个进程中可以包含多条线程
    • 多线程并发执行可以提高程序的效率, 可以同时完成多项工作
  • 2.多线程的应用场景
  • 红蜘蛛同时共享屏幕给多个电脑
    • 迅雷开启多条线程一起下载
    • QQ同时和多个人一起视频
    • 服务器同时处理多个客户端请求

24.02_多线程(多线程并行和并发的区别)(了解)

  • 并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
  • 并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。
  • 比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行。
  • 如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。

24.03_多线程(Java程序运行原理和JVM的启动是多线程的吗)(了解)

  • A:Java程序运行原理

  • Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。

  • B:JVM的启动是多线程的吗

  • JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。

    ```java package com.heima.thread;

    public class Demo1_Thread {

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
    /**
 * @param args
 * 证明jvm是多线程的
 */
public static void main(String[] args) {
    for(int i = 0; i < 100000; i++) {
        new Demo();
    }

    for(int i = 0; i < 10000; i++) {
        System.out.println("我是主线程的执行代码");
    }
}

    }

    class Demo {

    1
2
3
4
    @Override
public void finalize() {
    System.out.println("垃圾被清扫了");
}

    } ```

    执行:

    ```java

    ```

24.04_多线程(多线程程序实现的方式1)(掌握)

  • 1.继承Thread

  • 定义类继承Thread

    • 重写run方法

    • 把新线程要做的事写在run方法中

    • 创建线程对象

    • 开启新线程, 内部会自动执行run方法

      ```java package com.heima.thread;

      public class Demo2_Thread {

       1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
      /**
 * @param args
 */
public static void main(String[] args) {
    MyThread mt = new MyThread();       //4,创建Thread类的子类对象
    mt.start();                         //5,开启线程

    for(int i = 0; i < 1000; i++) {
        System.out.println("bb");
    }
}

      }

      class MyThread extends Thread { //1,继承Thread public void run() { //2,重写run方法 for(int i = 0; i < 1000; i++) { //3,将要执行的代码写在run方法中 System.out.println("aaaaaaaaaaaa"); } } } ```

24.05_多线程(多线程程序实现的方式2)(掌握)

  • 2.实现Runnable

  • 定义类实现Runnable接口

    • 实现run方法

    • 把新线程要做的事写在run方法中

    • 创建自定义的Runnable的子类对象

    • 创建Thread对象, 传入Runnable

    • 调用start()开启新线程, 内部会自动调用Runnable的run()方法

      ​

      ```java package com.heima.thread;

      public class Demo3_Thread {

       1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
      /**
 * @param args
 */
public static void main(String[] args) {
    MyRunnable mr = new MyRunnable(); // 4,创建Runnable的子类对象
    // Runnable target = mr; mr = 0x0011
    Thread t = new Thread(mr); // 5,将其当作参数传递给Thread的构造函数 ,还要讲对象传递给Thread
    t.start(); // 6,开启线程

    for (int i = 0; i < 1000; i++) {
        System.out.println("bb");
    }
}

      }

      class MyRunnable implements Runnable { // 1,定义一个类实现Runnable,继承的是Runnable

      1
2
3
4
5
6
      @Override
public void run() { // 2,重写run方法
    for (int i = 0; i < 1000; i++) { // 3,将要执行的代码写在run方法中
        System.out.println("aaaaaaaaaaaa");
    }
}

      } ```

24.06_多线程(实现Runnable的原理)(了解)

  • 查看源码
  • 1,看Thread类的构造函数,传递了Runnable接口的引用
    • 2,通过init()方法找到传递的target给成员变量的target赋值
    • 3,查看run方法,发现run方法中有判断,如果target不为null就会调用Runnable接口子类对象的run方法

24.07_多线程(两种方式的区别)(掌握)

  • 查看源码的区别:

  • a.继承Thread : 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法

    • b.实现Runnable : 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法

  • 继承Thread

  • 好处是:可以直接使用Thread类中的方法,代码简单

    • 弊端是:如果已经有了父类,就不能用这种方法

  • 实现Runnable接口

  • 好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的

    • 弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂

      24.08_多线程(匿名内部类实现线程的两种方式)(掌握)

  • 继承Thread类

    java new Thread() { //1,new 类(){}继承这个类 public void run() { //2,重写run方法 for(int i = 0; i < 3000; i++) { //3,将要执行的代码,写在run方法中 System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa"); } } }.start();

​
​

  • 实现Runnable接口

    java new Thread(new Runnable(){ //1,new 接口(){}实现这个接口 public void run() { //2,重写run方法 for(int i = 0; i < 3000; i++) { //3,将要执行的代码,写在run方法中 System.out.println("bb"); } } }).start();

    ```java package com.heima.thread;

    public class Demo4_Thread {

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
    /**
 * @param args
 */
public static void main(String[] args) {
    new Thread() {                                      //1,继承Thread类
        public void run() {                             //2,重写run方法
            for(int i = 0; i < 1000; i++) {             //3,将要执行的代码写在run方法中
                System.out.println("aaaaaaaaaaaaaa");
            }
        }
    }.start();                                          //4,开启线程

    new Thread(new Runnable() {                         //1,将Runnable的子类对象传递给Thread的构造方法
        public void run() {                             //2,重写run方法
            for(int i = 0; i < 1000; i++) {             //3,将要执行的代码写在run方法中
                System.out.println("bb");
            }
        }
    }).start();                                         //4,开启线程
}

    }

    ```

​

24.09_多线程(获取名字和设置名字)(掌握)

  • 1.获取名字

  • 通过getName()方法获取线程对象的名字

    ```java package com.heima.threadmethod;

    public class Demo0_SetName {

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
    /**
 * @param args
 */
public static void main(String[] args) {
    new Thread() {
        public void run() {
            // this.setName("张三");
            System.out.println(this.getName() + "....aaaaaaaaaaaaa");
        }
    }.start();

    new Thread() {
        public void run() {
            // this.setName("李四");
            System.out.println(this.getName() + "....bb");
        }
    }.start();
}

    }

    ```

    执行

    java Thread-0....aaaaaaaaaaaaa Thread-1....bb

  • 2.设置名字

  • 通过构造函数可以传入String类型的名字

    • ```java public static void demo1() { new Thread("芙蓉姐姐") { // 通过构造方法给name赋值 public void run() { System.out.println(this.getName() + "....aaaaaaaaa"); } }.start();

      1
2
3
4
5
6
          new Thread("凤姐") {
        public void run() {
            System.out.println(this.getName() + "....bb");
        }
    }.start();
}

      ```

    • 通过setName(String)方法可以设置线程对象的名字

      ```java package com.heima.threadmethod;

      public class Demo1_Name {

       1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
      /**
 * @param args
 */
public static void main(String[] args) {
    // demo1();
    Thread t1 = new Thread() {
        public void run() {
            // this.setName("张三");
            System.out.println(this.getName() + "....aaaaaaaaaaaaa");
        }
    };

    Thread t2 = new Thread() {
        public void run() {
            // this.setName("李四");
            System.out.println(this.getName() + "....bb");
        }
    };

    t1.setName("张三");
    t2.setName("李四");
    t1.start();
    t2.start();
}

public static void demo1() {
    new Thread("芙蓉姐姐") { // 通过构造方法给name赋值
        public void run() {
            System.out.println(this.getName() + "....aaaaaaaaa");
        }
    }.start();

    new Thread("凤姐") {
        public void run() {
            System.out.println(this.getName() + "....bb");
        }
    }.start();
}

      }

      ```

24.10_多线程(获取当前线程的对象)(掌握)

  • Thread.currentThread(), 主线程也可以获取

    ```java package com.heima.threadmethod;

    public class Demo2_CurrentThread {

    1
2
3
4
5
6
7
8
9
    /**
 * @param args
 */
public static void main(String[] args) {
    new Thread() {
        public void run() {
            System.out.println(getName() + "....aaaaaa");
        }
    }.start();

    ```

​ 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
        new Thread(new Runnable() {
            public void run() {
                //Thread.currentThread()获取当前正在执行的线程,因此这里使用的是自己定义的runnable,因此获取名字时候要调用Thread的方法
                System.out.println(Thread.currentThread().getName() + "...bb");
            }
        }).start();

        Thread.currentThread().setName("我是主线程");
        System.out.println(Thread.currentThread().getName());
    }

}

```

​

24.11_多线程(休眠线程)(掌握)

  • Thread.sleep(毫秒,纳秒), 控制当前线程休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000纳秒 1000000000

    ```java package com.heima.threadmethod;

    public class Demo3_Sleep {

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
    /**
 * @param args
 * @throws InterruptedException 
 */
public static void main(String[] args) throws InterruptedException {
    //demo1();
    new Thread() {
        public void run() {
            for(int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
                System.out.println(getName() + "...aaaaaaaaaa");
            }
        }
    }.start();

    new Thread() {
        public void run() {
            for(int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
                System.out.println(getName() + "...bb");
            }
        }
    }.start();
}

public static void demo1() throws InterruptedException {
    for(int i = 20; i >= 0; i--) {
        Thread.sleep(1000);
        System.out.println("倒计时第" +i + "秒");
    }
}

    }

    ```

​
​
​

24.12_多线程(守护线程)(掌握)

  • setDaemon(), 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出

    ```java package com.heima.threadmethod;

    public class Demo4_Daemon {

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
    /**
 * @param args
 * 守护线程
 */
public static void main(String[] args) {
    Thread t1 = new Thread() {
        public void run() {
            for(int i = 0; i < 2; i++) {
                System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaa");
            }
        }
    };

    Thread t2 = new Thread() {
        public void run() {
            for(int i = 0; i < 50; i++) {
                System.out.println(getName() + "...bb");
            }
        }
    };

    t2.setDaemon(true);                         //设置为守护线程

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

    }

    ```

    执行 守护线程也不是直接就退出的,是有时间的缓冲的

    java Thread-0...aaaaaaaaaaaaaaaaaaaa Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-0...aaaaaaaaaaaaaaaaaaaa Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb Thread-1...bb

​

24.13_多线程(加入线程)(掌握)

  • join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续

  • join(int), 可以等待指定的毫秒之后继续

    ```java package com.heima.threadmethod;

    public class Demo5_Join {

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
    /**
 * @param args
 *            join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
 */
public static void main(String[] args) {
    final Thread t1 = new Thread() {
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(getName() + "...aaaaaaaaaaaaa");
            }
        }
    };

    Thread t2 = new Thread() {
        public void run() {
            for (int i = 0; i < 10; i++) {
                if (i == 2) {
                    try {
                        // t1.join(); // 匿名内部类在调用外部方法的时候外部方法必须使用的是final进行修饰
                        t1.join(1); // 插队指定的时间,过了指定时间后,两条线程交替执行
                    } catch (InterruptedException e) {

                        e.printStackTrace();
                    }
                }
                System.out.println(getName() + "...bb");
            }
        }
    };

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

    }

    ```

​

24.14_多线程(礼让线程)(了解)

  • yield让出cpu 一般不明显
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.heima.threadmethod;

public class Demo6_Yield {

    /**
     * yield让出cpu礼让线程
     */
    public static void main(String[] args) {
        new MyThread().start();
        new MyThread().start();
    }

}

class MyThread extends Thread {
    public void run() {
        for(int i = 1; i <= 1000; i++) {
            if(i % 10 == 0) {
                Thread.yield();                     //让出CPU
            }
            System.out.println(getName() + "..." + i);
        }
    }
}

24.15_多线程(设置线程的优先级)(了解)

  • setPriority()设置线程的优先级
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package com.heima.threadmethod;

public class Demo7_Priority {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            public void run() {
                for(int i = 0; i < 100; i++) {
                    System.out.println(getName() + "...aaaaaaaaa" );
                }
            }
        };

        Thread t2 = new Thread(){
            public void run() {
                for(int i = 0; i < 100; i++) {
                    System.out.println(getName() + "...bb" );
                }
            }
        };

        //t1.setPriority(10);                   设置最大优先级
        //t2.setPriority(1);

        t1.setPriority(Thread.MIN_PRIORITY);        //设置最小的线程优先级
        t2.setPriority(Thread.MAX_PRIORITY);        //设置最大的线程优先级

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

}

24.16_多线程(同步代码块)(掌握)

  • 1.什么情况下需要同步

  • 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.

    • 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.

  • 2.同步代码块

  • 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块

    • 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的

      1
      ```java

      package com.heima.syn;

      public class Demo1_Synchronized {

       1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
      /**
 * @param args
 * 同步代码块
 */
public static void main(String[] args) {
    final Printer p = new Printer();

new Thread() {
        public void run() {
            while(true) {
                p.print1();
            }
        }
    }.start();

    new Thread() {
        public void run() {
            while(true) {
                p.print2();
            }
        }
    }.start();
}

      }

      class Printer { Demo d = new Demo(); public void print1() { //synchronized(new Demo()) { //同步代码块,锁机制,锁对象可以是任意的 synchronized(d) { System.out.print("黑"); System.out.print("马"); System.out.print("程"); System.out.print("序"); System.out.print("员"); System.out.print("\r\n"); } }

       1
 2
 3
 4
 5
 6
 7
 8
 9
10
      public void print2() {
    //synchronized(new Demo()) {                            //锁对象不能用匿名对象,因为匿名对象不是同一个对象
    synchronized(d) {       
        System.out.print("传");
        System.out.print("智");
        System.out.print("播");
        System.out.print("客");
        System.out.print("\r\n");
    }
}

      }

      class Demo{} //建立了任意一个类提供任意的对象 ```

24.17_多线程(同步方法)(掌握)

  • 使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
    package com.heima.syn;

    public class Demo2_Synchronized {

        /**
         * @param args
         * 同步代码块
         */
        public static void main(String[] args) {
            final Printer2 p = new Printer2();

            new Thread() {
                public void run() {
                    while(true) {
                        p.print1();
                    }
                }
            }.start();

            new Thread() {
                public void run() {
                    while(true) {
                        p.print2();
                    }
                }
            }.start();
        }

    }

    class Printer2 {
        Demo d = new Demo();
        //非静态的同步方法的锁对象是神马?
        //答:非静态的同步方法的锁对象是this
        //静态的同步方法的锁对象是什么?
        //是该类的字节码对象
        public static synchronized void print1() {                          //同步方法只需要在方法上加synchronized关键字即可
            System.out.print("黑");
            System.out.print("马");
            System.out.print("程");
            System.out.print("序");
            System.out.print("员");
            System.out.print("\r\n");
        }

        public static void print2() {
            //synchronized(new Demo()) {                            //锁对象不能用匿名对象,因为匿名对象不是同一个对象
            synchronized(Printer2.class) {      
                System.out.print("传");
                System.out.print("智");
                System.out.print("播");
                System.out.print("客");
                System.out.print("\r\n");
            }
        }
    }

​

24.18_多线程(线程安全问题)(掌握)

  • 多线程并发操作同一数据时, 就有可能出现线程安全问题

  • 使用同步技术可以解决这种问题, 把操作数据的代码进行同步, 不要多个线程一起操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package com.heima.syn;

    public class Demo3_Ticket {

        /**
         * 需求:铁路售票,一共100张,通过四个窗口卖完.
         */
        public static void main(String[] args) {
            new Ticket().start();
            new Ticket().start();
            new Ticket().start();
            new Ticket().start();
        }

    }

    class Ticket extends Thread {
        private static int ticket = 100;
        //private static Object obj = new Object();     //如果用引用数据类型成员变量当作锁对象,必须是静态的
        public void run() {
            while(true) {
                synchronized(Ticket.class) { //这里不能只用this,因为创建了多个的对象,使用this.class就是唯一的
                    if(ticket <= 0) {
                        break;
                    }
                    try {
                        Thread.sleep(10);               //线程1睡,线程2睡,线程3睡,线程4睡
                    } catch (InterruptedException e) {

                        e.printStackTrace();
                    }
                    System.out.println(getName() + "...这是第" + ticket-- + "号票");
                }
            }
        }
    }

​

24.19_多线程(火车站卖票的例子用实现Runnable接口)(掌握)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package com.heima.syn;

public class Demo4_Ticket {

    /**
     * @param args
     * 火车站卖票的例子用实现Runnable接口
     */
    public static void main(String[] args) {
        MyTicket mt = new MyTicket();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();

        /*Thread t1 = new Thread(mt);               //多次启动一个线程是非法的
        t1.start();
        t1.start();
        t1.start();
        t1.start();*/
    }

}

class MyTicket implements Runnable {
    private int tickets = 100;
    @Override
    public void run() {
        while(true) {
            synchronized(this) {  //synchronized(this)实现同步代码块,使用this是因为后面用的是一个对象
                if(tickets <= 0) {
                    break;
                }
                try {
                    Thread.sleep(10);               //线程1睡,线程2睡,线程3睡,线程4睡
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "...这是第" + tickets-- + "号票");
            }
        }
    }
}

24.20_多线程(死锁)(了解)

  • 多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁

  • 尽量不要嵌套使用

    ```java package com.heima.syn;

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
    public class Demo5_DeadLock {

    /**
     * @param args
     */
    private static String s1 = "筷子左";
    private static String s2 = "筷子右";

    public static void main(String[] args) {
        new Thread() {
            public void run() {
                while(true) {
                    synchronized(s1) {
                        System.out.println(getName() + "...获取" + s1 + "等待" + s2);
                        synchronized(s2) {
                            System.out.println(getName() + "...拿到" + s2 + "开吃");
                        }
                    }
                }
            }
        }.start();

        new Thread() {
            public void run() {
                while(true) {
                    synchronized(s2) {
                        System.out.println(getName() + "...获取" + s2 + "等待" + s1);
                        synchronized(s1) {
                            System.out.println(getName() + "...拿到" + s1 + "开吃");
                        }
                    }
                }
            }
        }.start();
    }
}

    ```

      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
    执行
```java
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-0...拿到筷子右开吃
Thread-0...获取筷子左等待筷子右
Thread-1...获取筷子右等待筷子左
执行到这里就被死锁了
```

24.21_多线程(以前的线程安全的类回顾)(掌握)

  • A:回顾以前说过的线程安全问题

  • 看源码：Vector,StringBuffer,Hashtable,Collections.synchroinzed(xxx)

    • Vector是线程安全的,ArrayList是线程不安全的
    • StringBuffer是线程安全的,StringBuilder是线程不安全的
    • Hashtable是线程安全的,HashMap是线程不安全的

    ​