Java 線程同步，java線程同步

Java 線程同步，java線程同步

Java 線程同步根本上是要符合一個邏輯:加鎖------>修改------>釋放鎖

1、同步代碼塊

示例如下：

public class SyncBlock {
    static class DataWrap {
        int i;
    }
    
    static class SyncBlockThread extends Thread {
        private DataWrap date;
        
        public SyncBlockThread(DataWrap dataWrap) {
            this.date = dataWrap;
        }
        
        @Override
        public void run() {
            
            for (int i = 0; i < 10; i++) {
                synchronized (date) {
                    date.i++;
                    try {
                        sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName() + " " + date.i);
                }
            }
        }
    }
    
    public static void main(String[] args) {
        //多線程實現變量i依次加一輸出
        DataWrap dataWrap = new DataWrap();
        
        new SyncBlockThread(dataWrap).start();
        new SyncBlockThread(dataWrap).start();
        new SyncBlockThread(dataWrap).start();
    }

}

示例中希望按照順序依次輸出整數。

通常同步代碼塊是需要鎖定的對象，一般是需要並發訪問的共享資源，任何線程在修改指定資源之前都首先對該資源加鎖，在加鎖期間其它線程無法修改該資源。從而保證了線程的安全性。另外線程在調用sleep或者yield時並不會讓出資源鎖。

2、同步方法

public class SyncMethod {
    
    static class DataWrap{
        int i;
        
        public synchronized void valueGrow(){
            i++;
            
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
    
    static class SyncMethodThread extends Thread {
        DataWrap dataWrap;
        
        public SyncMethodThread(DataWrap dataWrap){
            this.dataWrap = dataWrap;
        }
        
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                dataWrap.valueGrow();    
            }
        }
    }
    
    public static void main(String[] args) {
        //實現順序增長並輸出Datawrap中的i
        
        DataWrap dataWrap = new DataWrap();
        
        new SyncMethodThread(dataWrap).start();
        new SyncMethodThread(dataWrap).start();
        new SyncMethodThread(dataWrap).start();
    }

}

同步方法是使用synchronized關鍵字修飾的某個方法，同步方法鎖定的就是該對象本身，所以當一個線程調用了某個對象的同步方法後，如有其它線程調用該對象的其它同步方法，也依然要等待釋放該對象的鎖，因為該對象已被鎖定。

3、同步鎖

通過定義同步鎖對象實現同步，這種情況下，同步鎖使用Lock對象充當。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SyncLock {

    static class DataWrap{
        Lock lock = new ReentrantLock();
        int i;
        
        public void valueGrow(){
            lock.lock();
            try {
                i++;
                
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " " + i);    
            } finally {
                lock.unlock();
            }
            
        }
    }
    
    static class SyncLockThread extends Thread {
        DataWrap dataWrap;
        
        public SyncLockThread(DataWrap dataWrap){
            this.dataWrap = dataWrap;
        }
        
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                dataWrap.valueGrow();    
            }
        }
    }
    
    public static void main(String[] args) {
        //實現順序增長並輸出Datawrap中的i
        
        DataWrap dataWrap = new DataWrap();
                
        new SyncLockThread(dataWrap).start();
        new SyncLockThread(dataWrap).start();
        new SyncLockThread(dataWrap).start();
    }

}

使用鎖對象實現線程同步會更靈活一些，某些鎖還具有一些特定的功能，其中比較常用的ReadWriteLock讀寫鎖，ReentrantLock可重入鎖。