synchronized使用
synsynchronized的使用方法：
1、synchronized修饰方法
（1）synchronized修饰非静态方法: 锁的是方法的调用者
import java.util.concurrent.TimeUnit;
class Data {
/*synchronized修饰非静态方法，锁的是即方法的调用者，即
调用func1方法的对象*/
public synchronized void func1() {
try {
TimeUnit.SECONDS.sleep(3);//休眠3秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("1....");
}
public synchronized void func2() {
System.out.println("2....");
}
}
Test1:
public class Test1 {
public static void main(String[] args) {
Data data=new Data();
new Thread(()->{
data.func1();
}).start();
new Thread(()->{
data.func2();
}).start();
}
}
结果为：
在上面的代码中，由于synchronized修饰非静态方法:，锁的是方法的调用者；
所以 在本代码中锁的是Data类的对象，不同的Data对象，有不同的锁，但是此代码中只有一个data对象，第一个线程执行的是data.fun1()方法，第二个线程执行的是data.fun2()方法；
所以当第一个线程执行data.fun1()方法，获取到data对象的锁之后，执行data.fun1()方法，第二个线程获取不到data对象的锁，所以第二个线程中的方法data.fun2()方法无法执行；只有当第一个线程执行完毕（data.fun1()方法执行完），释放了data锁之后，第二个线程才能获取到data的锁，执行data.fun2()方法；
Test2：
public class Test1 {
public static void main(String[] args) {
Data data = new Data();
Data data2 = new Data();
new Thread(() -> {
data.func1();
}).start();
new Thread(() -> {
data2.func2();
}).start();
}
}
结果为：
在上面的代码中，由于synchronized修饰非静态方法:，锁的是方法的调用者；
所以锁的是Data类的对象，不同的Data对象，有不同的锁，此代码中有两个Data对象：data，data2；
所以当第一个线程获取到data对象的锁之后，执行data.fun1()方法；第二个线程执行的是data2.fun2()方法，其与第一个线程获取的不是同一个对象的锁，所以也能与第一个线程同时执行，但fun1()方法中，线程休眠了3秒，所以结果先输出2，再输出1；
（2）synchronized修饰静态方法:锁的是class本身
class Data2 {
/*synchronized修饰静态方法，锁的是class本身，本代码中
锁的是Data2这个类本身，锁定的不是对象*/
public synchronized static void func1() {
try {
TimeUnit.SECONDS.sleep(3);//休眠3秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("1....");
}
public synchronized static void func2() {
System.out.println("2....");
}
}
Test1:
public class Test2 {
public static void main(String[] args) {
Data2 data1=new Data2();
new Thread(()->{
data1.func1();
}).start();
new Thread(()->{
data1.func2();
}).start();
}
}
结果为：
上面的代码中，由于synchronized修饰静态方，:锁的是class本身；
所以第一个线程执行data1.func1()方法，获取到了Data类的锁；而第二个线程中执行的方法是data1.func2()方法，但因为第一个线程已经获取了Data类的锁，所以无法获取锁，只有当第一个线程执行完data1.func1()方法之后，释放了Data类的锁，第二个线程才能运行执行获取到Data类的锁，执行data1.func2()方法；
Test2:
public class Test2 {
public static void main(String[] args) {
Data2 data1=new Data2();
Data2 data2=new Data2();
new Thread(()->{
data1.func1();
}).start();
new Thread(()->{
data2.func2();
}).start();
}
}
结果为：
在上面的代码中，synchronized修饰的是静态方法（static修饰的方法），则锁的是class本身；
所以在本代码中，锁的是Data.class这个类对象，由于一个类只有一个class对象，所以不管该类有几个实例对象，当一个线程获取该类的锁之后，其他线程就无法获取该类的锁了，只有当上一个线程释放了锁之后，其他线程才能获取这个类的锁，执行方法
2、synchronized修饰代码块
（1）synchronized（类对象）即synchronized（class）：锁的是同一个类
class Data3{
public void func1(Integer num) {
synchronized (Data3.class) {//锁的是同一个类
System.out.println("start....");
try {
TimeUnit.SECONDS.sleep(3);//休眠3秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end....");
}
}
}
Test:
import java.util.concurrent.TimeUnit;
public class Test3 {
public static void main(String[] args) {
Data3 data=new Data3();
for(int i=0;i<5;i++){
Integer num=Integer.valueOf(i);
new Thread(()->{
data.func1(num);
}).start();
}
}
}
结果为：
由于代码中 synchronized (Data3.class)锁的是Data3.class这个类对象，
所以对于代码中的那5个线程，每次执行fun1(num)方法时，只有当一个线程获取到Data3.class这个类的锁之后，执行完func1(num)方法，释放了Data3.class的锁之后，才能执行下一个线程；
（2）synchronized(对象)：锁的是同一个对象
class Data3{
public void func2(Integer num) {
synchronized (num) {//锁的是同一个num对象
System.out.println(num+"start....");
try {
TimeUnit.SECONDS.sleep(3);//休眠3秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end....");
}
}
}
Test:
import java.util.concurrent.TimeUnit;
public class Test3 {
public static void main(String[] args) {
Data3 data=new Data3();
for(int i=0;i<5;i++){
Integer num=Integer.valueOf(1);//同一个num对象
new Thread(()->{
data.func2(num);
}).start();
}
}
}
结果为：
由于代码中 synchronized (num)锁的是num这个实例对象；
又由于 Integer num=Integer.valueOf(1)，不管创建多少次，都是对应的堆中的同一个对象，
所以对于代码中的那5个线程，每次执行fun2(num)方法时，锁的时同一个num，只有当一个线程获取到num这个对象的锁之后，执行完func2(num)方法，释放了num的锁之后，才能执行下一个线程；
Test3:
public class Test3 {
public static void main(String[] args) {
Data3 data=new Data3();
for(int i=0;i<5;i++){
Integer num=Integer.valueOf(i);//不同的num对象
new Thread(()->{
data.func2(num);
}).start();
}
}
}
结果为：
由于代码中 synchronized (num)锁的是num这个实例对象；
又由于 Integer num=Integer.valueOf(i)，这5次创建过程中，对应的是不同的num实例对象；
所以对于代码中的那5个线程，每次执行fun2(num)方法时，锁的都不是同一个num的锁，他们互不影响，所以5个线程同时执行；