我是小康小白,一个平平无奇的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: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的执行权,并不会释放手中持有的锁。
兄弟们,小白编写不易。(这道题真的对于之前的小白而言,很烧脑。)希望各位兄弟们,点赞评论收藏加关注。小白在此谢谢各位老爷们。
对于白嫖的兄弟们,