标签：new t 而不是 stack 一个个 dex 类锁 cat rri start
Synchronized修饰方法：对象锁
Static Synchronized修饰方法：类锁
下面代码手动敲一遍，就会理解
一、Synchronized修饰方法
package sync;
public class MultiThread {
private int num = 0;
public synchronized void printNum(String tag) {
try {
if(tag.equals("a")) {
num = 100;
System.out.println("tag a , set num over!");
Thread.sleep(1000);
System.out.println("tag " + tag + ", num = " + num);
}else {
num = 200;
System.out.println("tag b , set num over!");
Thread.sleep(1000);
System.out.println("tag " + tag + ", num = " + num);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
//新建两个对象m1 、m2
MultiThread m1 = new MultiThread();
MultiThread m2 = new MultiThread();
//新建第一个线程，调用m1对象的printNum()方法
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
m1.printNum("a");
}
});
//新建第二个线程，调用m2对象的printNum()方法
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
m2.printNum("b");
}
});
//同时启动两个线程
t1.start();
t2.start();
//是先执行完线程t1，再执行线程t2吗？
}
}
输出结果：
tag b , set num over! tag a , set num over! tag b, num = 200 tag a, num = 100
可以看到，线程t1和线程t2是同时执行，两个线程互不影响，独立执行，因此输出结果自然不分先后.
第一个对象m1访问后，锁住m1这个对象；然后，第二个对象m2继续访问，不会被m1锁影响到。
结论：
（1）synchronized是对象锁，多个对象多个锁，锁的是对象。
（2）而不是把一个方法或者一个类当作锁（一个Class类可以new多个对象嘛）
二、Static Synchronized修饰方法
在静态方法上加上synchronized关键字，表示锁定class类，类一级别的锁（独占class类）
无论new多少个对象去访问该静态synchronized方法，都要排队一个个访问，竞争同一把锁（class这个锁）
package sync;
public class MultiThread {
private static int num = 0;
public static synchronized void printNum(String tag) {
try {
if(tag.equals("a")) {
num = 100;
System.out.println("tag a , set num over!");
Thread.sleep(1000);
System.out.println("tag " + tag + ", num = " + num);
}else {
num = 200;
System.out.println("tag b , set num over!");
Thread.sleep(1000);
System.out.println("tag " + tag + ", num = " + num);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
//新建两个对象m1 、m2
MultiThread m1 = new MultiThread();
MultiThread m2 = new MultiThread();
//新建第一个线程，调用m1对象的printNum()方法
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
m1.printNum("a");
}
});
//新建第二个线程，调用m2对象的printNum()方法
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
m2.printNum("b");
}
});
//同时启动两个线程
t1.start();
t2.start();
//是先执行完线程t1，再执行线程t2吗？
}
}
输出结果：
tag b , set num over! tag b, num = 200 tag a , set num over! tag a, num = 100
可以看到：
先执行完一个线程，再执行下一个线程
结论：
（1）static synchronized是类锁，锁住这个类
标签：new t 而不是 stack 一个个 dex 类锁 cat rri start
原文地址：https://www.cnblogs.com/Donnnnnn/p/9060060.html
