コミュニティ 学ぶ ツールライブラリ レジャー
検索
日本語
ホームページ > Java > ＆＃＆はじめる > 本文

Javaスレッド同期とは何ですか

爱喝马黛茶的安东尼
リリース： 2019-12-09 16:29:46
オリジナル
3441 人が閲覧しました

Javaスレッド同期とは何ですか

#スレッド同期

複数のスレッド間で同じオブジェクトを呼び出す場合、操作の安全性と正確性を確保するために、各スレッドで使用されたときにオブジェクトの結果が正しく、オブジェクトのステータスが適切であることを保証するためにオブジェクトを同期する必要があります。この部分には、同期やスレッド ロックなどの知識ポイントが含まれます。この部分には、同期と同期ロック (Lock) の概念のみが含まれます。

synchronized

synchronized キーワードはオブジェクトとメソッドを変更できます。通常の使用法は次のとおりです: 

//同步代码块
synchronized（Object object）{
...
}
//或者
//同步方法
public synchronized void test(){
...
}
ログイン後にコピー

同期モニターという概念があります。上記のような同期コードブロックの object オブジェクトと同期メソッドの this オブジェクトが同期的に監視されます 複数のスレッドが同期コードブロックまたはメソッドを同時に呼び出した場合、同期監視オブジェクトのロックを取得できるスレッドは 1 つだけですコードの実行後、ロックは後まで解放されません。この期間中、他の呼び出しスレッドは、呼び出し前にロックが解放されるのを待つことしかできません。

上記のSellRunnableクラスのsellメソッドでもsynchronizedを使用していますが、上記のコードは実行速度が速すぎて感知できませんが、修正するとsynchronizedとsynchronizedの違いが分かります。 

public class ThreadTest {
    public static void main(String[] args) {
        SellRunnable sellRunnable = new SellRunnable();
        Thread thread1 = new Thread(sellRunnable, "1");
        Thread thread2 = new Thread(sellRunnable, "2");
        Thread thread3 = new Thread(sellRunnable, "3");
        thread2.start();
        thread1.start();
        thread3.start();
    }
}
class SellRunnable implements Runnable {
    //有十张票
    int index = 10;
    public void sell() {
        if (index >= 1) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            index--;
            System.out.println("售货窗口：" + Thread.currentThread().getName() + 
            " 卖出了一张票,剩余：
            " + index);
        } else {
            System.out.println("售货窗口：" + Thread.currentThread().getName() + " 买票时没票了");
        }
    }
    @Override
    public void run() {
        while (index > 0) {
            System.out.println("售货窗口：" + Thread.currentThread().getName() + " 开始买票");
            sell();
        }
    }
}
//执行结果：
售货窗口：1 开始买票
售货窗口：2 开始买票
售货窗口：3 开始买票
售货窗口：2  卖出了一张票,剩余：9
售货窗口：2 开始买票
售货窗口：1  卖出了一张票,剩余：9
售货窗口：1 开始买票
售货窗口：3  卖出了一张票,剩余：8
售货窗口：3 开始买票
售货窗口：1  卖出了一张票,剩余：6
售货窗口：1 开始买票
售货窗口：2  卖出了一张票,剩余：6
售货窗口：2 开始买票
售货窗口：3  卖出了一张票,剩余：5
售货窗口：3 开始买票
售货窗口：1  卖出了一张票,剩余：4
售货窗口：1 开始买票
售货窗口：2  卖出了一张票,剩余：3
售货窗口：3  卖出了一张票,剩余：2
售货窗口：3 开始买票
售货窗口：2 开始买票
售货窗口：3  卖出了一张票,剩余：1
售货窗口：2  卖出了一张票,剩余：0
售货窗口：1  卖出了一张票,剩余：1
Process finished with exit code 0  //可以看到，票数减少是错误的
//sell方法添加synchronized修饰符后 执行结果：
public synchronized void sell() {
        if (index >= 1) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            index--;
            System.out.println("售货窗口：" + Thread.currentThread().getName() + 
            " 卖出了一张票,剩余：
            " + index);
        } else {
            System.out.println("售货窗口：" + Thread.currentThread().getName() + " 买票时没票了");
        }
    }
售货窗口：2 开始买票
售货窗口：3 开始买票
售货窗口：1 开始买票
售货窗口：2  卖出了一张票,剩余：9
售货窗口：2 开始买票
售货窗口：1  卖出了一张票,剩余：8
售货窗口：1 开始买票
售货窗口：3  卖出了一张票,剩余：7
售货窗口：3 开始买票
售货窗口：1  卖出了一张票,剩余：6
售货窗口：1 开始买票
售货窗口：2  卖出了一张票,剩余：5
售货窗口：2 开始买票
售货窗口：1  卖出了一张票,剩余：4
售货窗口：1 开始买票
售货窗口：1  卖出了一张票,剩余：3
售货窗口：1 开始买票
售货窗口：3  卖出了一张票,剩余：2
售货窗口：3 开始买票
售货窗口：1  卖出了一张票,剩余：1
售货窗口：1 开始买票
售货窗口：1  卖出了一张票,剩余：0
售货窗口：2 买票时没票了
售货窗口：3 买票时没票了
Process finished with exit code 0  // 可以看到，票数是正常减少的
ログイン後にコピー

上記の sell メソッドの同期後、ある瞬間に 1 つのスレッドだけがこのメソッドを呼び出すため、インデックスを判定したときに得られる結果が正しい結果になります。

上記の同期では、動作効率を下げることでスレッドの安全性を確保しているため、スレッドクラス内の不要なメソッドやオブジェクトは同期せず、競合するリソースやオブジェクトのみを同期するようにしてください。同期されています。

同期の識別後、次の時点でロックを解放できます。

コード ブロック、メソッドの実行が完了します (正常に完了、リターンまたはブレーク、例外がスローされます)

呼び出しwait メソッドは、現在のスレッドを一時停止するために使用されます。

スレッドが同期されたコード ブロックを実行する場合、sleep メソッドと yield メソッドは同期ロックを解放しません。また、suspend メソッドも解放しません (スレッド操作中にスレッドの状態を操作するためにサスペンドと再開を使用することは避けてください。

Synchronized Lock

上記の synchronized は Java のキーワードであり、「When」にも記載されています。スリープ中または IO 操作を実行している場合、スレッドはスレッド ロックを解放せず、他のスレッドは待機する必要があります。これにより実行効率が低下する場合があるため、スレッドがブロックされたときにスレッド ロックを解放できる代替手段が必要です。この問題を解決するために。

Lock は Java のクラスで、java.util.concurrent.locks パッケージ内にあります。具体的なコードは次のとおりです。 

public interface Lock {
    void lock();//加锁
    void lockInterruptibly() throws InterruptedException;//加锁
    boolean tryLock();//加锁
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;//加锁
    void unlock();//释放锁
    Condition newCondition();//线程协作中用到
}
ログイン後にコピー

Lock インターフェイスの実装サブクラスは、Java の ReentrantLock です。 util.concurrent.locks パッケージの下にある ReentrantLock のソース コードは次のとおりです: 

public class ReentrantLock implements Lock, Serializable {
    private static final long serialVersionUID = 7373984872572414699L;
    private final ReentrantLock.Sync sync;
    public ReentrantLock() {
        this.sync = new ReentrantLock.NonfairSync();
    }
    public ReentrantLock(boolean var1) {//是否创建公平锁
        this.sync = (ReentrantLock.Sync)(var1?new ReentrantLock.FairSync():new  ReentrantLock.
        NonfairSync());
    }
    public void lock() {
        this.sync.lock();
    }
    public void lockInterruptibly() throws InterruptedException {
        this.sync.acquireInterruptibly(1);
    }
    public boolean tryLock() {
        return this.sync.nonfairTryAcquire(1);
    }
    public boolean tryLock(long var1, TimeUnit var3) throws InterruptedException {
        return this.sync.tryAcquireNanos(1, var3.toNanos(var1));
    }
    public void unlock() {
        this.sync.release(1);
    }
    public Condition newCondition() {
        return this.sync.newCondition();
    }
    public int getHoldCount() {//当前线程持有该锁的数量
        return this.sync.getHoldCount();
    }
    public boolean isHeldByCurrentThread() {//该锁是否被当前线程持有
        return this.sync.isHeldExclusively();
    }
    public boolean isLocked() {//是否被其他线程持有该锁
        return this.sync.isLocked();
    }
    public final boolean isFair() {//是否是公平锁
        return this.sync instanceof ReentrantLock.FairSync;
    }
    protected Thread getOwner() {//当前锁的持有线程
        return this.sync.getOwner();
    }
    public final boolean hasQueuedThreads() {//是否有线程在等待该锁
        return this.sync.hasQueuedThreads();
    }
    public final boolean hasQueuedThread(Thread var1) {//目标线程是否在等待该锁
        return this.sync.isQueued(var1);
    }
    public final int getQueueLength() {//等待该锁线程的数量
        return this.sync.getQueueLength();
    }
    protected Collection<Thread> getQueuedThreads() {//获取所有等待该锁的线程集合
        return this.sync.getQueuedThreads();
    }
    ...
    
}
ログイン後にコピー

ロックの使用方法

lock

lock() を使用してロックを取得しますが、他のスレッドがロックを占有している場合は待機します。 

public class LockTest {
    public static void main(String[] args) {
        com.test.java.SellRunnable sellRunnable = new com.test.java.SellRunnable();
        Thread thread1 = new Thread(sellRunnable, "1号窗口");
        Thread thread2 = new Thread(sellRunnable, "2号窗口");
        Thread thread3 = new Thread(sellRunnable, "3号窗口");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}
ログイン後にコピー
public class SellRunnable implements Runnable {
    //有十张票
    int index = 10;
    Lock lock = new ReentrantLock();
    public void sell() {
        try {
            lock.lock();
            System.out.println("售货柜台：" + Thread.currentThread().getName() + 
            "获取了票源+++++");
            if (index >= 1) {
                index--;
                System.out.println("售货柜台：" + Thread.currentThread().getName() + 
                "卖出了一张票,剩余：
                " + index);
            } else {
                System.out.println("售货柜台：" + Thread.currentThread().getName() + 
                "买票时没票了000");
            }
        } finally {
            lock.unlock();
        }
    }
    @Override
    public void run() {
        while (index > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            sell();
        }
    }
}
ログイン後にコピー

実行結果: 

售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：9
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：8
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：7
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：6
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：5
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：4
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：3
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：2
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：1
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：0
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口买票时没票了000
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口买票时没票了000
Process finished with exit code 0  //每一个窗口都随机获取票源、然后卖出票
ログイン後にコピー

tryLock

tryLock() はロックの取得を試みます。取得に成功した場合は true を返し、失敗した場合は false を返します。待機状態にはなりません。 

public class SellRunnable implements Runnable {
    //有十张票
    int index = 10;
    Lock lock = new ReentrantLock();
    public void sell() {
        if (lock.tryLock()) {
            try {
                System.out.println("售货柜台：" + Thread.currentThread().getName() + 
                "获取了票源+++++");
                if (index >= 1) {
                    index--;
                    System.out.println("售货柜台：" + Thread.currentThread().getName() + 
                    "卖出了一张票,剩余：" + index);
                } else {
                    System.out.println("售货柜台：" + Thread.currentThread().getName() + 
                    "买票时没票了000");
                }
            } finally {
                lock.unlock();
            }
        } else {
           System.out.println("售货柜台：" + Thread.currentThread().getName()+"没有获取票源！！！");
        }
    }
    @Override
    public void run() {
        while (index > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            sell();
        }
    }
}
ログイン後にコピー

実行結果: 

售货柜台：1号窗口获取了票源+++++
售货柜台：3号窗口没有获取票源！！！
售货柜台：2号窗口没有获取票源！！！
售货柜台：1号窗口卖出了一张票,剩余：9
售货柜台：2号窗口没有获取票源！！！
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：8
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：7
售货柜台：1号窗口没有获取票源！！！
售货柜台：3号窗口没有获取票源！！！
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：6
售货柜台：1号窗口获取了票源+++++
售货柜台：2号窗口没有获取票源！！！
售货柜台：3号窗口没有获取票源！！！
售货柜台：1号窗口卖出了一张票,剩余：5
售货柜台：2号窗口获取了票源+++++
售货柜台：1号窗口没有获取票源！！！
售货柜台：2号窗口卖出了一张票,剩余：4
售货柜台：3号窗口没有获取票源！！！
售货柜台：1号窗口获取了票源+++++
售货柜台：2号窗口没有获取票源！！！
售货柜台：3号窗口没有获取票源！！！
售货柜台：1号窗口卖出了一张票,剩余：3
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：2
售货柜台：2号窗口获取了票源+++++
售货柜台：3号窗口没有获取票源！！！
售货柜台：2号窗口卖出了一张票,剩余：1
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：0
售货柜台：3号窗口没有获取票源！！！
售货柜台：2号窗口没有获取票源！！！
Process finished with exit code 0//没有获取到货源的票口，就直接没有等待，进入下次买票
ログイン後にコピー

tryLock(long time, TimeUnit単位)

tryLock(long time, TimeUnit単位)は、次の場合に一定時間待機するように設定できます。ロックを取得できません。 //最初のパラメータは常に長く、2 番目のパラメータは時間単位です 

public class SellRunnable implements Runnable {
    //有十张票
    int index = 10;
    Lock lock = new ReentrantLock();
    public void sell() {
        try {
            if (lock.tryLock(1000, TimeUnit.MILLISECONDS)) {
                try {
                    System.out.println("售货柜台：" + Thread.currentThread().getName() + 
                    "获取了票源+++++");
                    if (index >= 1) {
                        index--;
                        System.out.println("售货柜台：" + Thread.currentThread().getName()
                         +"卖出了一张票,剩余：" + index);
                    } else {
                        System.out.println("售货柜台：" + Thread.currentThread().
                        getName()  + "买票时没票了000");
                    }
                    try {
                        Thread.sleep(2000);//人为加入买票时间
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } finally {
                    lock.unlock();
                }
            } else {
                System.out.println("售货柜台：" + Thread.currentThread().getName() + 
                "没有获取票源！！！");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        while (index > 0) {
            try {
                Thread.sleep(500);//要不执行太快，看不出效果
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            sell();
        }
    }
}
ログイン後にコピー

実行結果:

售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：9
售货柜台：2号窗口没有获取票源！！！
售货柜台：3号窗口没有获取票源！！！
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：8
售货柜台：3号窗口没有获取票源！！！
售货柜台：1号窗口没有获取票源！！！
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：7
售货柜台：1号窗口没有获取票源！！！
售货柜台：2号窗口没有获取票源！！！
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：6
售货柜台：2号窗口没有获取票源！！！
售货柜台：3号窗口没有获取票源！！！
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：5
售货柜台：3号窗口没有获取票源！！！
售货柜台：1号窗口没有获取票源！！！
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：4
售货柜台：1号窗口没有获取票源！！！
售货柜台：2号窗口没有获取票源！！！
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：3
售货柜台：2号窗口没有获取票源！！！
售货柜台：3号窗口没有获取票源！！！
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：2
售货柜台：3号窗口没有获取票源！！！
售货柜台：1号窗口没有获取票源！！！
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：1
售货柜台：1号窗口没有获取票源！！！
售货柜台：2号窗口没有获取票源！！！
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：0
售货柜台：2号窗口没有获取票源！！！
售货柜台：3号窗口没有获取票源！！！
Process finished with exit code 0 //当买票时间大约等待时间时，则没有获取票源的窗口不买票，进入下个买票机会
ログイン後にコピー

チケット購入時間の短縮:

try {
    Thread.sleep(500);//人为加入买票时间
} catch (InterruptedException e) {
    e.printStackTrace();
}
ログイン後にコピー

実行結果:

售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：9
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：8
售货柜台：3号窗口没有获取票源！！！
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：7
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：6
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：5
售货柜台：3号窗口没有获取票源！！！
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：4
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：3
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：2
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：1
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：0
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口买票时没票了000
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口买票时没票了000
Process finished with exit code 0 //等待时间内获取到票源了，也就卖出票了
ログイン後にコピー

lockInterruptibly

lockInterruptibly() このメソッドでロックを取得するとき、そのロックが別のスレッドによって保持されている場合は待機状態になりますが、この待機プロセスは Thread Theオブジェクトの割り込みメソッドは待機を中断できます。割り込みが発生すると、InterruptedException がスローされます。これをキャッチするか、スローするように宣言する必要があります。 

public class ThreadTest {
    public static void main(String[] args) {
        SellRunnable sellRunnable = new SellRunnable();
        Thread thread1 = new Thread(sellRunnable, "1号窗口");
        Thread thread2 = new Thread(sellRunnable, "2号窗口");
        Thread thread3 = new Thread(sellRunnable, "3号窗口");
        thread1.start();
        try {
            Thread.sleep(500);//确保窗口1号先获取锁
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.start();
        thread3.start();
        try {
            Thread.sleep(2000);//等待两秒后，打断窗口2、3的等待
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.interrupt();
        thread3.interrupt();
    }
}
SellRunnable中等待时间加长：
try {
    Thread.sleep(5000);//人为加入买票时间
} catch (InterruptedException e) {
    e.printStackTrace();
}
ログイン後にコピー

実行結果:

售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：9
售货柜台：3号窗口被打断了      //这个地方被打断了
售货柜台：2号窗口被打断了      //这个地方被打断了
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：8
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：7
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：6
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：5
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：4
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：3
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：2
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：1
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：0
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口买票时没票了000
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口买票时没票了000
Process finished with exit code 0
ログイン後にコピー

synchronizedとLockの比較

上記のコードを通して、違いがわかります。 Lock と synchronized の間 いくつかの接続と相違点:

どちらもリエントラント ロックです

リエントラント ロックとは、スレッドがオブジェクト ロックを取得した後、ブロックされずに再度オブジェクト ロックを取得できることを意味します。たとえば、同じクラス内の複数のメソッド (または再帰的に呼び出されるメソッド) が同期またはロックされた後、同じスレッドはこれら 2 つのメソッドの呼び出し時にブロックされることなくオブジェクトのロックを取得できます。

非リエントラント ロックの例: 

public class Lock{
    private boolean isLocked = false;
    public void lock(){
        while(isLocked){    
            wait();
        }
        isLocked = true;
    }
    public void unlock(){
        isLocked = false;
        notify();
    }
}
//使用方法：
public class Test{
    Lock lock = new Lock();
    public void test1(){
        lock.lock();
        test2();
        lock.unlock();
    }
    public void test2(){
        lock.lock();
        ...
        lock.unlock();
    }
}
ログイン後にコピー

Test クラスが test1 メソッドを呼び出し、lock.lock() の実行後に test2 を呼び出すと、永久に待機してデッド状態になります。

リエントラントロックの設計原則: 

public class Lock{
    private boolean isLocked = false;
    private Thread lockedThread = null;
    int lockedCount = 0;
    public void lock(){
        Thread thread = Thread.currentThread();
        while(isLocked && thread != lockedThread){    
            wait();
        }
        isLocked = true;
        lockedCount++;
        lockedThread = thread;
    }
    public void unlock(){
        Thread thread = Thread.currentThread();
        if(thread == lockedThread){    
            lockedCount--;
            if(lockedCount == 0){
                isLocked = false;
                lockedThread = null;
                notify();
            }
        }
    }
}
ログイン後にコピー

Test クラスの test1 メソッドを呼び出した後、test2 メソッドもスムーズに実行できます。

実装の観点から見ると、synchronized は基本的にカウンターを使用して再入可能を実現します。

ロックは割り込み可能なロックであり、同期は割り込みできません。

当一个线程B执行被锁的对象的代码时，发现线程A已经持有该锁，那么线程B就会进入等待，但是synchronized就无法中断该等待过程，而Lock就可以通过lockInterruptibly方法抛出异常从而中断等待，去处理别的事情。

Lock可创建公平锁，synchronized是非公平锁。

公平锁的意思是按照请求的顺序来获取锁，不平公锁就无法保证线程获取锁的先后次序。

Lock可以知道是否获取到锁，synchronized不可以。

synchronized在发生异常或者运行完毕，会自动释放线程占有的锁。而Lock需要主动释放锁，否则会锁死；

synchronized在阻塞时，别的线程无法获取锁，Lock可以（这也是lock设计的一个目的）。

读写锁

多个线程对同一个文件进行写操作时，会发生冲突所以需要加锁，但是对同一个文件进行读操作的时候，使用上面的方法会造成效率的降低，所以基于这种情况，产生了ReadWriteLock这个接口：

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading.
     */
    Lock readLock();//读的锁
 
    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing.
     */
    Lock writeLock();//写的锁
}
ログイン後にコピー

这个接口的实现类是ReentrantReadWriteLock，其源代码如下：

public class ReentrantReadWriteLock implements ReadWriteLock, Serializable {
    private static final long serialVersionUID = -6992448646407690164L;
    private final ReentrantReadWriteLock.ReadLock readerLock;
    private final ReentrantReadWriteLock.WriteLock writerLock;
    ...
    public ReentrantReadWriteLock.WriteLock writeLock() {//获取write lock
        return this.writerLock;
    }
    public ReentrantReadWriteLock.ReadLock readLock() {//获取read lock
        return this.readerLock;
    }
    ...
}
ログイン後にコピー

使用方法和Lock一样，使用到write时调用writeLock()方法获取lock进行加锁，使用到read时调用readLock()方法进行加锁，需要注意的知识点如下：

线程A占用写锁，线程B在申请写、读的时候需要等待。

线程A占用读锁，线程B在申请写操作时，需要等待。

线程A占用读锁，线程B获取读操作时可以获取到。

总结

如果需要效率提升，则建议使用Lock，如果效率要求不高，则synchronized满足使用条件，业务逻辑写起来也简单，不需要手动释放锁。

PHP中文网，有大量免费的JAVA入门教程，欢迎大家学习！

以上がJavaスレッド同期とは何ですかの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。

関連ラベル：
java スレッドの同期
ソース：php.cn
前の記事：MacシステムのターミナルでJavaプログラムをコンパイルして実行する方法 次の記事：Java にはどのような認定資格がありますか?
このウェブサイトの声明
この記事の内容はネチズンが自主的に寄稿したものであり、著作権は原著者に帰属します。このサイトは、それに相当する法的責任を負いません。盗作または侵害の疑いのあるコンテンツを見つけた場合は、admin@php.cn までご連絡ください。
著者別の最新記事
最新の問題
自動四捨五入を行わずにJavaScriptで文字列を19桁の数値に変換するにはどうすればよいですか? 数値に変換したい場合は、文字列入力 number input="6145390195186705543" があります。Java スクリプトはこの入力を自動的に丸...
から 2024-03-30 14:42:35
0
1
367
関連トピック
詳細>
人気のおすすめ
人気のチュートリアル
詳細>
関連するチュートリアル
人気のおすすめ
最新のコース
最新のダウンロード
詳細>
ウェブエフェクト
公式サイト
サイト素材
フロントエンドテンプレート