Java + 线程系列之synchronized同步锁(五)

同样 新建了一个synDemo类 来展示

public class SynDemo {

private static Integer count = 10000;

//锁是什么
// 锁是一个对象
// 假如A线程先访问这个del方法
// 那么锁对象就会被A线程持特有其他(BCD)想访问del方法的时候
// 就会发现锁对象被A线程拿走了,
// 那么(BCD)就都不能进入到del方法中
// 当A线程执行完毕del方法,会将锁对象释放出来
// 这时候(BCD)线程再争夺执行权.
// 谁抢到了,谁来执行sel方法 谁执行sel方法,
// 那么谁就又拿到了锁对象
// 这个时候剩下的两个线程就又进不来del方法中了

//使用关键字的两种方式
//1, 在方法声明上,使用synchronized关键字修饰
//2, 使用synchronized代码块将要执行的代码包起来
public synchronized void del() {
for (int i = 0; i < 2500; i++) {
count -= 1;
System.out.println(Thread.currentThread().getName() + "========" + count);
}
}
//2, 使用synchronized代码块将要执行的代码包起来
public void del1() {
synchronized (this) {
for (int i = 0; i < 2500; i++) {
count -= 1;
System.out.println(Thread.currentThread().getName() + "========" + count);

b99f
}
}
}

//show方法,也是被synchronized关键字修饰的
// 而synchronized关键字修饰的方法的锁的对象,就是该方法的调用者
//对象.方法() 这里调用show方法,与调用del方法的对象是一个
//所以,show方法的锁对象与del方法的锁对象也就是一个了

//而第一个线程已经进入了del方法,也就持有了锁对象
// 第二个线程想要进入show方法
// 需要等第一个线程从del方法中出来,释放锁对象的时候,才能进入到show方法中
public synchronized void show(){
for (int i = 0; i < 2000; i++) {
System.out.println("*********show********");
}
}

public void show1(){
synchronized (count){
for (int i = 0; i < 2000; i++) {
System.out.println("*****show1*****");
}
}
}
}

//Main函数中调用
private static void showSynchronized() {
SynDemo sy = new SynDemo();
new Thread(new Runnable() {
@Override
public void run() {
sy.show();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
sy.del1();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
sy.show1();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
sy.del();
}
}).start();
}

** //synchronized,表示同步的意思

//同步可以理解成等待某一件事情结束才能开始做下一件事情

//同步:是阻塞的,就是你做了这件事情,没做完就做不了其他的事情了

//异步:就是做了一件事情没有做完就可以去做别的事情了**