- 簡介
synchronized是Java中的的關(guān)鍵字叁温，是一種同步鎖，可以修飾以下幾種
1.1>：類
作用的范圍是：synchronized后邊括號括起來的部分
作用的對象是：這個類當(dāng)中所有的對象
1.2>：靜態(tài)方法
作用的范圍是：整個靜態(tài)方法
作用的對象是：這個類當(dāng)中的所有對象
1.3>：代碼塊：被修飾的代碼塊稱為同步代碼塊
作用的范圍是：大括號括起來的部分
作用的對象是：調(diào)用這個代碼塊的對象
1.4>：方法：被修飾的方法稱為同步方法
作用的范圍是：整個方法
作用的對象是：調(diào)用這個方法的對象 - 實例分析
2.1>： synchronized修飾的代碼塊
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity" ;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
SyncThread syncThread = new SyncThread() ;
Thread thread1 = new Thread(syncThread , "SyncThread1") ;
Thread thread2 = new Thread(syncThread , "SyncThread2") ;
thread1.start();
thread2.start();
}
class SyncThread implements Runnable{
private int count ;
public SyncThread(){
count = 0 ;
}
@Override
public void run() {
synchronized (this){
for (int i = 0; i < 5; i++) {
try {
Log.d("mainActivity-->", Thread.currentThread().getName() + ":" + (count++)) ;
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public int getCount(){
return count ;
}
}
}
上邊運行結(jié)果是
//SyncThread2:0
//SyncThread2:1
//SyncThread2:2
//SyncThread2:3
//SyncThread2:4
//SyncThread1:5
//SyncThread1:6
//SyncThread1:7
//SyncThread1:8
//SyncThread1:9
由以上可知：
當(dāng)兩個線程thread1和thread2訪問 "同一個syncThread對象" 中的synchronized代碼塊辩越，同一時刻只能一個執(zhí)行線程像棘，另一個受阻，必須等當(dāng)前線程執(zhí)行完這個代碼塊后才能執(zhí)行棺牧，thread1在執(zhí)行synchronized代碼塊時會鎖定當(dāng)前對象隔盛，只有執(zhí)行完該代碼塊后才能釋放對象鎖犹菱，下一個線程才能執(zhí)行并鎖定該對象
我們現(xiàn)在把
Thread thread1 = new Thread(syncThread , "SyncThread1") ;
Thread thread2 = new Thread(syncThread , "SyncThread2") ;
這兩句修改為
Thread thread1 = new Thread(new SyncThread() , "SyncThread1") ;
Thread thread2 = new Thread(new SyncThread() , "SyncThread2") ;
運行結(jié)果是
//SyncThread1:0
//SyncThread2:0
//SyncThread1:1
//SyncThread2:1
//SyncThread1:2
//SyncThread2:2
//SyncThread1:3
//SyncThread2:3
//SyncThread1:4
//SyncThread2:4
現(xiàn)象：
thread1和thread2同時在執(zhí)行
原因：
synchronized修飾代碼塊時，只鎖定代碼塊中的對象吮炕，一個對象只有一個鎖 [ lock ] 與之關(guān)聯(lián)腊脱，而上邊代碼等同于
SyncThread syncThread1 = new SyncThread();
SyncThread syncThread2 = new SyncThread();
Thread thread1 = new Thread(syncThread1, "SyncThread1");
Thread thread2 = new Thread(syncThread2, "SyncThread2");
thread1.start();
thread2.start();
這個時候創(chuàng)建了2個對象，分別為 syncThread1何syncThread2龙亲，線程thread1執(zhí)行syncThread1對象中對應(yīng)synchronized的代碼陕凹，線程thread2執(zhí)行syncThread2中對應(yīng)的synchronized對象，我們都知道synchronized鎖定的是對象鳄炉，這個時候會有兩把鎖分別鎖定syncThread1對象和syncThread2對象杜耙，而這兩把鎖互補(bǔ)干擾，所以兩個線程可以同時執(zhí)行
代碼：https://github.com/shuai999/ThreadDemo
2.2：當(dāng)一個線程訪問一個對象的synchronized(this)代碼塊時拂盯，其他線程也可以訪問該對象的非synchronized(this)代碼塊佑女，并且不受阻塞
多個線程訪問同一個對象的synchronized(this)代碼塊和非synchronized(this)代碼塊，示例如下：
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Counter counter = new Counter() ;
//參數(shù)一：Runnable的實現(xiàn)類 參數(shù)二：線程名
Thread thread1 = new Thread(counter , "A") ;
Thread thread2 = new Thread(counter , "B") ;
thread1.start();
thread2.start();
}
class Counter implements Runnable{
private int count ;
public Counter(){
count = 0 ;
}
public void countAdd(){
//synchronized代碼塊
synchronized (this){
for (int i = 0; i < 5; i++) {
try {
Log.d("threadName--->" , Thread.currentThread().getName() +":" + (count++)) ;
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//非synchronized代碼塊磕仅，未對count進(jìn)行讀寫操作珊豹，所以可以不用synchronized
public void printAdd(){
for (int i = 0; i < 5; i++) {
try {
Log.d("threadName--->" , Thread.currentThread().getName() + "count:" + count) ;
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
@Override
public void run() {
String threadName = Thread.currentThread().getName() ;
if (threadName.equals("A")){
countAdd();
}else if (threadName.equals("B")){
printAdd();
}
}
}
// Bcount:0
// A:0
// Bcount:1
// A:1
// Bcount:2
// A:2
// Bcount:3
// A:3
// Bcount:4
// A:4
/* 以上是運行結(jié)果 */
/* 由結(jié)果可知簸呈，countAdd()方法是synchronized代碼塊榕订，printAdd()不是synchronized代碼塊。
當(dāng)一個線程訪問一個對象的synchronized代碼塊時蜕便，其他的線程可以訪問該對象的非synchronized代碼塊而不受阻塞*/
}
具體代碼已上傳至github：
https://github.com/shuai999/ThreadDemo3
2.3：指定給某個對象加鎖
代碼如下：
/**
* @author : Created by ces
* @date: on 2018/1/28.
* @function: 指定給某個對象加鎖
*/
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Account account = new Account("zhangsan" , 10000.0f) ;
AccountOperator operator = new AccountOperator(account) ;
final int THREAD_NUM = 5 ;
Thread threads[] = new Thread[THREAD_NUM] ;
for (int i = 0; i < THREAD_NUM; i++) {
threads[i] = new Thread(operator , "Thread" + i);
threads[i].start();
}
}
public class AccountOperator implements Runnable{
private Account account ;
public AccountOperator(Account account){
this.account = account ;
}
@Override
public void run() {
synchronized (account){
//存錢500
account.deposit(500);
//取錢500
account.withDraw(500);
Log.e("cesAccount--->", Thread.currentThread().getName() + ":" + account.getBalance()) ;
//運行結(jié)果如下
// Thread0:10000.0
// Thread1:10000.0
// Thread2:10000.0
// Thread3:10000.0
// Thread4:10000.0
}
}
}
}
/**
* @author : Created by ces
* @date: on 2018/1/28.
* @function: 指定給某個對象加鎖
*/
public class Account {
String name ;
float amount ;
public Account(String name , float amount){
this.name = name ;
this.amount = amount ;
}
//存錢
public void deposit(float amt){
amount +=amt;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//取錢
public void withDraw(float amt){
amount -=amt ;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public float getBalance(){
return amount ;
}
}
在AccountOperator類中劫恒，我們給account對象加了鎖，這時當(dāng)一個線程訪問account對象時轿腺，其他線程就會阻塞两嘴，直到該線程訪問account對象結(jié)束，也就是說誰拿到那個鎖族壳，誰就可以運行它所控制的那段代碼憔辫。
具體代碼已上傳至github
https://github.com/shuai999/ThreadDemo4.git
2.4 修飾一個方法
格式：public synchronized void method(){//todo};
synchronized修飾方法和代碼塊類似，只是作用范圍不一樣：
修飾的代碼塊是大括號括起來的范圍仿荆；
修飾的方法是整個函數(shù)贰您；
在用synchronized修飾方法時注意以下幾點：
1.synchronized關(guān)鍵字不能被繼承
1.1 ：如果在父類中某個方法使用了synchronized坏平，而在子類中覆蓋此方法，在子類中這個方法默認(rèn)并不是同步的锦亦，必須顯式的在方法中加synchronized才可以舶替；
1.2：還可以在子類方法中調(diào)用父類中相應(yīng)的方法，這樣雖然子類中方法不是同步的杠园，但子類調(diào)用了父類的同步方法顾瞪，因此，子類的方法也就相當(dāng)于同步了抛蚁，這兩種方式代碼如下：
在子類方法上邊加上synchronized：
class Parent{
public synchronized void method(){}
}
class Child extends Parent{
public synchronized void method(){}
}
在子類方法中調(diào)用父類的同步方法：
class Parent{
public synchronized void method(){}
}
class Childe extends Parent{
public void method(){
super.method() ;
}
}
注意：
1>：在定義接口方法時不能使用synchronized
2>：在構(gòu)造方法中不能用synchronized陈醒，但可以使用synchronized代碼塊來進(jìn)行同步
2.5：修飾一個靜態(tài)方法,，代碼如下
public synchronized static void method() {
// todo
}
2.6：修飾一個類篮绿，代碼如下：
class ClassName {
public void method() {
synchronized(ClassName.class) {
// todo
}
}
}
總結(jié)：
1>：無論synchronized加在方法上還是對象上孵延，如果它作用的對象是非靜態(tài)的，則它取得的鎖是對象亲配；如果synchronized作用的是一個靜態(tài)方法或一個類尘应，則它取得的對象是該類，該類所有的對象是同一把鎖；
2>：每個對象只有一個鎖 [ lock ]與之相關(guān)聯(lián)抒蚜，誰拿到這個鎖稠氮，誰就可以運行它所控制的那段代碼；
3>：實現(xiàn)同步是需要很大的系統(tǒng)開銷作為代價玷犹，甚至造成死鎖，所以盡量避免無謂的同步控制洒疚。
