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

我是小康小白，一个平平无奇的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的执行权，并不会释放手中持有的锁。

---

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

对于白嫖的兄弟们，