线程题目（实现线程的交替运行）以及类似题目weixin45791445的博客-

我是小康小白，一个平平无奇的Java小白。热爱有趣的文字，生活和远方。 个人博客：https://blog.csdn.net/weixin_45791445 

编程要求（实现三个线程间隔运行）

实现代码

package step3;  public class MyThread implements Runnable {     private String name;     private Object prev;     private Object self;      private MyThread(String name, Object prev, Object self) {         this.name = name;         this.prev = prev;         this.self = self;     }       public void run() {         int count = 5;         while (count > 0) {             synchronized (prev) {                 synchronized (self) {                     System.out.print(name);                     count--;                      self.notify();                 }                 try {                     prev.wait();                 } catch (InterruptedException e) {                     e.printStackTrace();                 }             }          }         System.exit(0);     }      public static void main(String[] args) throws Exception {         Object a = new Object();         Object b = new Object();         Object c = new Object();         MyThread pa = new MyThread("E", c, a);         MyThread pb = new MyThread("D", a, b);         MyThread pc = new MyThread("U", b, c);           new Thread(pa).start();         Thread.sleep(100);           new Thread(pb).start();         Thread.sleep(100);         new Thread(pc).start();         Thread.sleep(100);     }      }  

类似题目（实现两个线程间隔运行）

实现代码

public class MyThread implements Runnable {        private String name;        private Object prev;        private Object self;        private MyThread(String name, Object prev, Object self) {            this.name = name;            this.prev = prev;            this.self = self;        }        public void run() {            int count = 5;            while (count > 0) {                synchronized (prev) {                    synchronized (self) {                        System.out.print(name);                        count--;                       self.notify();                    }                    try {                        prev.wait();                    } catch (InterruptedException e) {                         e.printStackTrace();                 }                }            }           System.exit(0);//退出jvm     }        public static void main(String[] args) throws Exception {            Object a = new Object();            Object b = new Object();            MyThread ta = new MyThread("A", b, a);            MyThread tb = new MyThread("B", a, b);            new Thread(ta).start();         Thread.sleep(100);  //确保按顺序A、B执行         new Thread(tb).start();         Thread.sleep(100);           }    } 

运行结果

ABABABABAB 

上面两道分别实现了将三个字母间隔输出和将两个字母间隔输出 。小白推荐大家可以去找找不同，这样有助于理解，看看实现了间隔输出的是那一部分，而实现了间隔输出两个或者三个的不同在哪里？

下面是小白对于代码的解释。

对象锁。同一时间只保证 一个线程访问方法或变量。
在Java语言中，通过被关键字synchronized修饰的方法或synchronized语句块实现对代码的同步
包含在synchronized方法或语句块中的代码称为被同步的代码(Synchronized Code)
当线程访问被同步的代码时，必须首先竞争代码所属的类的【对象上的锁】，否则线程将等待(阻塞)，直到锁被释放。

wait()就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行；

相应的notify()会唤醒其它等待该对象锁的出于堵塞状态的线程，并释放该对象锁操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁。然后JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间隔同步、唤醒的操作。

Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。

对第二道题进行讲解

首先看一张图，后面会用

解释

1. 首先

   代码段1：MyThread ta = new MyThread(“A”, b, a);
   MyThread tb = new MyThread(“B”, a, b);
   实例化了对象ta和对象tb，由代码段3可知
   此时在对象ta中name=“A” , prev=b , self=a;
   对象tb中name=“B”，prev=a,self=b;

代码段2：new Thread(ta).start(); 

将这个对象创建一个新的线程（后面用线程ta来代表），并调用start方法将线程ta就绪，由于此时没有其它线程，此线程或得CPU执行权开始运行，调用对应的run()方法。
在run方法中
所先，synchronized保证了只有一个线程能够进入运行（实现原理），所以此时线程ta持有prev（此时是实例对象锁b）进入运行，然后

   synchronized (self) {                         System.out.print(name);                         count--;                        self.notify();                     }    

线程ta再次持有self（即实例对象锁a）进入运行（此时线程ta持有实例对象锁a,b），输出name(即“A”)，count-1,然后线程ta调用self.notify(),被转化为就绪状态。 由于此时 被synchronized (self)包裹的代码已经运行完毕，所以线程ta会释放实例对象锁a。 cpu再从同等优先级的线程中选择某个线程去执行（还是有可能会选择到此线程）。
然后线程ta调用了wait()方法，进入了堵塞状态,暂时放弃对CPU的使用权,停止执行,就会释放线程ta此时持有的对象锁b。（为什么）然后调用notify()通知调用过wait方法的线程可以去参与获得锁的竞争了 。CPU则会再寻找一个新的线程去运行，而，

Thread.sleep(100);  //确保按顺序A、B执行 

这一段代码是为了确保线程ta出于堵塞状态。
此时程序继续向下运行，

tb线程被由新建状态转化为就绪状态，由于ta线程出于堵塞状态，处于就绪状态的只有tb线程。tb线程开始运行。相同的，tb线程开始调用run方法，由于对象锁b没用被其它线程持有，tb拿到了对象锁b,然后进入 synchronized 修饰的代码块中。同理，由于对象锁a没被占用，所以拿到对象锁a。进入代码段，输出“B”，然后线程tb调用self.notify(),被转化为就绪状态。并且会唤醒等待对象锁a的线程ta 由于此时 被synchronized (self)包裹的代码已经运行完毕，所以线程tb会释放实例对象锁b。

然后，线程tb调用prev.wait();变为堵塞状态，释放对象锁a。
线程ta再次拿到了对象锁b,已经对象锁a。然后顺利运行了下去，输出“A”。当先后遇到self.notify();prev.wait();执行相同的操作，释放其本身对象锁a，唤醒出于堵塞状态的线程tb，然后释放实例对象锁b。然后线程ta变为堵塞状态，等待线程tb运行到self.notify();时将它唤醒。

剩余的过程就是上面的不断循环，最终在count变为0时，run()方法运行结束。线程死亡。

synchronized的实现原理
将synchronized作用于一个给定的实例对象（就是synchronized后面括号里的，例如上面的代码synchronized (prev)中的prev ），即当前实例对象就是锁对象，每次当线程进入synchronized包裹的代码块时就会要求当前线程持有prev实例对象锁，如果当前有其他线程正持有该对象锁，那么新到的线程就必须等待，这样也就保证了每次只有一个线程执行i++;操作。

为什么线程ta会释放它所持有的对象锁
synchronized关键字修饰时，当此线程调用wait()方法后，就会释放所持有的实例对象锁。补充一下sleep()同样是让线程出于堵塞状态，但是线程只会交出cpu的执行权，并不会释放手中持有的锁。

兄弟们，小白编写不易。（这道题真的对于之前的小白而言，很烧脑。）希望各位兄弟们，评论加关注。小白在此谢谢各位老爷们。

对于白嫖的兄弟们，