多个线程,每个线程都可以拿到自己指定的锁,分别或得锁之后,执行synchronized方法体的内容。
public class MyThread {
private int num = 0;
/** static */
public synchronized void printNum(String tag){
try {
if(tag.equals("a")){
num = 100;
System.out.println("tag a, set num over!");
Thread.sleep(1000);
} else {
num = 200;
System.out.println("tag b, set num over!");
}
System.out.println("tag " + tag + ", num = " + num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
//俩个不同的对象
final MyThread m1 = new MyThread();
final MyThread m2 = new MyThread();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
m1.printNum("a");
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
m2.printNum("b");
}
});
t1.start();
t2.start();
}
}
m1,m2两个不同的对象调用printNum两个线程都进到printNum方法里了,如果m1进到线程里,则打印结果输出tar a num=100,然后输出,而代码的结果是m1,m2同时进来。
总结:一个对象一把锁(也就是说,两个线程分别是得到m1,m2这两个对象的锁,他们两个没有任何关系)
如果说有一天当前有一个线程执行printNum方法,我就不希望其他的线程进来执行,怎么办呢??
在方法上加static,全局变量加static,表示的是在静态的方法上加上synchronized修饰,那么这个线程调用printNum所或得的锁,就是class这个类级别的锁,无论实例化多少个对象,都没有任何关联关系。也就是说t1,t2线程有一个先后执行的顺序。
关键字synchronized取得的锁都是对象锁,而不是把一段代码(方法)当作锁,示例代码中那个线程先执行synchronized关键字的方法,那个线程就持有该方法所属对象的锁,(lock),两个对象,线程获得的就是两个不同的锁,他们互不影响。
有一种情况则是相同的锁,即在静态方法上加上synchronized关键字,表示锁定.class类,类一级别的锁,(独占,class类)。