Java基礎之synchronized

synchronized
synchronized是一個同步鎖關鍵字，作用就是讓線程只能逐一執行，不能并行執行，至于底層怎么實現，不是我這種連用都不會的人改關注的。
用法
– 修飾代碼快（非靜態）
測試代碼（不加synchronized）：
public class Synchronized {
public static void main (String[] args) {
Teacher teacher = new Teacher();
Thread first = new SynchronizedThread("first", teacher);
Thread second = new SynchronizedThread("second", teacher);
first.start();
second.start();
}
static class SynchronizedThread extends Thread {
private String name;
private Teacher teacher;
public SynchronizedThread (String name, Teacher teacher) {
this.name = name;
this.teacher = teacher;}
@Override
br/>}
@Override
teacher.say(name);
}
}
static class Teacher {
public void say(String name) {
System.out.println("我正在教" + name);
//System.out.println("線程進入睡眠");
SleepUtil.sleep(3000);
System.out.println(name + "睡眠三秒");
}
}
}
執行結果：
我正在教first
我正在教second
second睡眠三秒
first睡眠三秒
兩個睡眠三秒幾乎是同時出現。
測試代碼（加synchronized）：
static class Teacher {
public void say(String name) {
System.out.println("我正在教" + name);
synchronized (this) {
//System.out.println("線程進入睡眠");
SleepUtil.sleep(3000);
System.out.println(name + "睡眠三秒");
}
}
}
輸出結果：
我正在教first
我正在教second
first睡眠三秒
second睡眠三秒
雖然看著是一樣的，實際輸出的時候，是先輸出一個睡眠三秒，3秒之后，再輸出一個睡眠三秒。
總結：在多個線程操作同一個對象，執行加鎖的對象方法的時候，逐一執行同步代碼塊中的代碼，鎖的是對象實例
– 修飾對象方法
測試代碼（加synchronized）：
static class Teacher {
public synchronized void say(String name) {
System.out.println("我正在教" + name);
SleepUtil.sleep(3000);
System.out.println(name + "睡眠三秒");
}
}
執行結果：
我正在教first
first睡眠三秒
我正在教second
second睡眠三秒
可以看到輸出結果是先是一個線程（first）執行了方法，然后是另外一個線程（second）執行了方法。
測試代碼（不加synchronized）：
static class Teacher {
public void say(String name) {
System.out.println("我正在教" + name);
SleepUtil.sleep(3000);
System.out.println(name + "睡眠三秒");
}
}
執行結果：
我正在教first
我正在教second
second睡眠三秒
first睡眠三秒
可以看到兩個線程幾乎同時執行了，這和代碼塊的測試是一樣的結果。
測試代碼（一個方法不加synchronized，一個方法加synchronized）：
public class Synchronized {
public static void main (String[] args) {
Teacher teacher = new Teacher();
Thread first = new SynchronizedThread("first", teacher);
Thread second = new AnotherSynchronizedThread("second", teacher);
first.start();
second.start();
}
static class SynchronizedThread extends Thread {
private String name;
private Teacher teacher;
public SynchronizedThread (String name, Teacher teacher) {
this.name = name;
this.teacher = teacher;}
@Override
br/>}
@Override
teacher.say(name);
}
}
static class AnotherSynchronizedThread extends Thread {
private String name;
private Teacher teacher;
public AnotherSynchronizedThread (String name, Teacher teacher) {
this.name = name;
this.teacher = teacher;}
@Override
br/>}
@Override
teacher.hello(name);
}
}
static class Teacher {
public synchronized void say(String name) {
System.out.println("我正在教" + name);
SleepUtil.sleep(3000);
System.out.println(name + "睡眠三秒");
}
public void hello(String name) {
System.out.println("我會說hello");
System.out.println("hello " + name);
}
}
}
執行結果：
我正在教first
我會說hello
hello second
first睡眠三秒
可以看到，多線線程執行同一個對象的同步方法和非同步方法的時候，兩個方法的執行相互不影響。
測試代碼（一個方法加synchronized，另外一個方法也加synchronized）：
static class Teacher {
public synchronized void say(String name) {
System.out.println("我正在教" + name);
SleepUtil.sleep(3000);
System.out.println(name + "睡眠三秒");
}
public synchronized void hello(String name) {
System.out.println("我會說hello");
System.out.println("hello " + name);
}
}
執行結果：
我正在教first
first睡眠三秒
我會說hello
hello second
雖然結果不能明顯看出輸出順序，但是執行時我能看到是先執行一個方法，執行完之后再執行另外一個方法。
測試代碼（一個靜態方法不加synchronized，一個對象方法加synchronized）：
public class Synchronized {
public static void main (String[] args) {
Teacher teacher = new Teacher();
Thread first = new SynchronizedThread("first", teacher);
Thread second = new AnotherSynchronizedThread("second", teacher);
first.start();
second.start();
}
static class SynchronizedThread extends Thread {
private String name;
private Teacher teacher;
public SynchronizedThread (String name, Teacher teacher) {
this.name = name;
this.teacher = teacher;}
@Override
br/>}
@Override
teacher.say(name);
}
}
static class AnotherSynchronizedThread extends Thread {
private String name;
private Teacher teacher;
public AnotherSynchronizedThread (String name, Teacher teacher) {
this.name = name;
this.teacher = teacher;}
@Override
br/>}
@Override
Teacher.hello(name);
}
}
static class Teacher {
public synchronized void say(String name) {
System.out.println("我正在教" + name);
SleepUtil.sleep(3000);
System.out.println(name + "睡眠三秒");
}
public static void hello(String name) {
System.out.println("我會說hello");
System.out.println("hello " + name);
}
}
}
執行結果：
我正在教first
我會說hello
hello second
first睡眠三秒
從結果上可以看到，對象方法上加同步對靜態方法沒有影響。
另外靜態方法加上了synchronized，兩個方法的執行之間也不影響。
總結：1、首先靜態方法加不加同步，對實例方法沒什么影響；
2、加同步的實例方法，對不加同步的實例方法沒什么影響；
3、只有都是實例方法并且都加同步的情況下，才會出現同步逐一執行的效果；
靜態方法
– 靜態方法
上面已經知道了對象方法加同步，對靜態方法沒有影響。
測試代碼（兩個靜態方法加synchronized）：
static class Teacher {
public static synchronized void say(String name) {
System.out.println("我正在教" + name);
SleepUtil.sleep(3000);
System.out.println(name + "睡眠三秒");
}
public static synchronized void hello(String name) {
System.out.println("我會說hello");
System.out.println("hello " + name);
}
}
執行結果：
我正在教first
first睡眠三秒
我會說hello
hello second
可以看到，是先執行了一個方法，再執行另外一個方法。
測試代碼（一個靜態方法加synchronized，一個靜態方法不加synchronized）：
static class Teacher {
public static synchronized void say(String name) {
System.out.println("我正在教" + name);
SleepUtil.sleep(3000);
System.out.println(name + "睡眠三秒");
}
public static void hello(String name) {
System.out.println("我會說hello");
System.out.println("hello " + name);
}
}
執行結果：
我正在教first
我會說hello
hello second
first睡眠三秒
兩個方法的執行沒有影響。
總結：靜態方法方法加同步只對加了XM代理申請www.fx61.com/brokerlist/xm.html同步的靜態方法有影響。
以上都是常規的寫法，實例方法給對象實例枷鎖，靜態方法給類枷鎖。還有一些其它的寫法。
其它寫法
測試代碼（在實例方法上加synchronized，加鎖的是類）：
static class Teacher {
public static void say(String name) {
synchronized(Teacher.class) {
System.out.println("我正在教" + name);
SleepUtil.sleep(3000);
System.out.println(name + "睡眠三秒");
}
}
public static synchronized void hello(String name) {
System.out.println("我會說hello");
System.out.println("hello " + name);
}
}
執行結果：
我正在教first
first睡眠三秒
我會說hello
hello second
執行效果，類似與兩個加了同步的靜態方法，這種寫法是給類加鎖，所有需要同步類的方法都會受影響。
測試代碼（定義一個類變量（是一個對象），用來同步）：
public class Synchronized {
private static Test lock = new Test();
public static void main (String[] args) {
Teacher teacher = new Teacher();
Thread first = new SynchronizedThread("first", teacher);
Thread second = new AnotherSynchronizedThread("second", teacher);
first.start();
second.start();
}
static class SynchronizedThread extends Thread {
private String name;
private Teacher teacher;
public SynchronizedThread (String name, Teacher teacher) {
this.name = name;
this.teacher = teacher;}
@Override
br/>}
@Override
teacher.say(name);
}
}
static class AnotherSynchronizedThread extends Thread {
private String name;
private Teacher teacher;
public AnotherSynchronizedThread (String name, Teacher teacher) {
this.name = name;
this.teacher = teacher;}
@Override
br/>}
@Override
Teacher.hello(name);
}
}
static class Teacher {
public void say(String name) {
synchronized(lock) {
System.out.println("我正在教" + name);
SleepUtil.sleep(3000);
System.out.println(name + "睡眠三秒");
}
}
public static void hello(String name) {
synchronized(lock) {
System.out.println("我會說hello");
System.out.println("hello " + name);
}
}
}
static class Test {
}
}
執行結果：
我正在教first
first睡眠三秒
我會說hello
hello second
這種寫法等效于類加同步，或者實例加同步，不過同步的對象變為了自己定義的另外一個對象。
synchronized同步：
同步實例對象時，只對使用這個對象鎖的方法有影響；
同步類時，只對使用這個類鎖的方法有影響；