Java线程同步的几种方式

最新推荐文章于 2024-08-09 09:30:00 发布
最新推荐文章于 2024-08-09 09:30:00 发布
阅读量81 收藏
点赞数
文章标签： java
原文链接：https://juejin.im/post/5b9486fdf265da0ad13b5dfc
版权

本文主要是介绍java中线程同步的几种常用方式。

CountDownLatch

从字面上理解，CountDownLatch是一个同步等待的锁，根据官方的注释可以看出这其实是一个同步执行工具类。

先看一下官方注释的前两段

/**
 * A synchronization aid that allows one or more threads to wait until
 * a set of operations being performed in other threads completes.
 *
 * <p>A {@code CountDownLatch} is initialized with a given <em>count</em>.
 * The {@link #await await} methods block until the current count reaches
 * zero due to invocations of the {@link #countDown} method, after which
 * all waiting threads are released and any subsequent invocations of
 * {@link #await await} return immediately.  This is a one-shot phenomenon
 * -- the count cannot be reset.  If you need a version that resets the
 * count, consider using a {@link CyclicBarrier}.
 
复制代码

翻译一下就是：

 /**
  * CountDownLatch是一个，允许一个或多个线程，
  * 等待其他线程中执行的一组操作完成的，同步辅助工具。
  * 
  * CountDownLatch用给定的计数进行初始化。 
  * 当线程点用await方法后被阻塞，直到当前计数由于其他线程调用countDown()方法而达到零，
  * 此后所有等待线程被放，并且任何后续调用await立即返回。
  * 这是一次性的操作，计数无法重置。
  * 如果您需要重置计数的版本，请考虑使用CyclicBarrier。
  * /
复制代码

解释的很清楚，不在赘述，接着看一下官方提供的伪代码案例

官方案例一
class Driver { // ...
   void main() throws InterruptedException {
     CountDownLatch startSignal = new CountDownLatch(1);
     CountDownLatch doneSignal = new CountDownLatch(N);

     for (int i = 0; i < N; ++i) // create and start threads
       new Thread(new Worker(startSignal, doneSignal)).start();

     doSomethingElse();            // don't let run yet
     startSignal.countDown();      // let all threads proceed
     doSomethingElse();
     doneSignal.await();           // wait for all to finish
   }
 }

 class Worker implements Runnable {
   private final CountDownLatch startSignal;
   private final CountDownLatch doneSignal;
   Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
     this.startSignal = startSignal;
     this.doneSignal = doneSignal;
   }
   public void run() {
     try {
       startSignal.await();
       doWork();
       doneSignal.countDown();
     } catch (InterruptedException ex) {} // return;
   }

   void doWork() { ... }
 }
复制代码

这个案例很直白的说明了，CountDownLatch可以让多个线程同时初始化完成后等待，直到主线程要求他们开始执行为止，并且当主线程调用await()之后阻塞直到所有的线程调用countDown()将计数减为0，主线程再次唤醒执行后序操作。

当然这样还有一些其他的注意点，譬如子线程被中断或者子线程的耗时操作很长导致主线程一直阻塞等问题。

官方案例二
class Driver2 { // ...                                      
  void main() throws InterruptedException {                 
    CountDownLatch doneSignal = new CountDownLatch(N);      
    Executor e = ...                                        
                                                            
    for (int i = 0; i < N; ++i) // create and start threads 
      e.execute(new WorkerRunnable(doneSignal, i));         
                                                            
    doneSignal.await();           // wait for all to finish 
  }                                                         
}                                                           
                                                            
class WorkerRunnable implements Runnable {                  
  private final CountDownLatch doneSignal;                  
  private final int i;                                      
  WorkerRunnable(CountDownLatch doneSignal, int i) {        
    this.doneSignal = doneSignal;                           
    this.i = i;                                             
  }                                                         
  public void run() {                                       
    try {                                                   
      doWork(i);                                            
      doneSignal.countDown();                               
    } catch (InterruptedException ex) {} // return;         
  }                                                         
                                                            
  void doWork() { ... }                                     
  }
}                                                   
复制代码

这个案例是说，当一个问题需要被分成n份进行处理时，将他们用线程池来执行，并让主线程等待。当然官方注释里还说了，如果需要反复用这种形式来执行一些问题时可以考虑使用CyclicBarrier来代替CountDownLatch，因为CountDownLatch是一次性的计数器无法重置。

CyclicBarrier

字面意思：可循环使用的栅栏。主要的作用也是让指定个数的线程到达目标位置后进入等到状态，等所有的线程都到到目标位置后同时开始执行。

构造方法有2个

  1. CyclicBarrier(int parties)，其中parties指等待的线程数目，当await线程数达到parties时，线程同时开始执行。
  2. CyclicBarrier(int parties, Runnable barrierAction)，第二个参数指所有线程达到后执行的操作。

通过第二个构造方法也可以实现CountDownLatch功能，当然这不是CyclicBarrier的目的

再来看一下到达目标位置时的等待方法，有2个重载方法

  1. await()，这个没什么可说的，到达指定位置后等待
  2. await(long timeout, TimeUnit unit)，这个指到到指定位置后等待一段时间，如果超时则继续执行后序操作。

现在来看2个例子说明一下使用CyclicBarrier可能出现的问题

CyclicBarrier例一
public class CyclicBarrierTest {

    public static void main(String[] args) {

        try {
            final int Num = 5;
            CyclicBarrier cyclicBarrier = new CyclicBarrier(Num);

            for (int i = 0; i < Num - 1; i++) {
                new Thread(new RunnableOne(cyclicBarrier)).start();
            }

            Thread thread = new Thread(new RunnableTwo(cyclicBarrier));
            thread.start();

            Thread.sleep(2000);

            thread.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    private static class RunnableOne implements Runnable {

        CyclicBarrier mCyclicBarrier;

        RunnableOne(CyclicBarrier cyclicBarrier) {
            mCyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            try {
                System.out.println("wait in barrier");
                mCyclicBarrier.await();
                System.out.println("finish");
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

    private static class RunnableTwo implements Runnable {

        CyclicBarrier mCyclicBarrier;

        RunnableTwo(CyclicBarrier cyclicBarrier) {
            mCyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            try {
                System.out.println("wait in barrier");
                Thread.sleep(5000);
                mCyclicBarrier.await();
                System.out.println("finish");
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }
}
复制代码

打印结果如下：

wait in barrier
wait in barrier
wait in barrier
wait in barrier
wait in barrier
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at com.jxx.myjavatest.CyclicBarrierTest$RunnableTwo.run(CyclicBarrierTest.java:65)
	at java.lang.Thread.run(Thread.java:748)

复制代码

这个例子的意图也很简单，启动4个RunnableOne，随后启动1个RunnableTwo，在所有线程都await()之前其中一个线程被中断了，因为没有都await()成功，其他4个线程就一直阻塞。 这就提醒我们，要在抛出异常后及时处理，至少也要让其他线程能正常执行下去。

CyclicBarrier例二
public class CyclicBarrierTest {

    public static void main(String[] args) {

        final int Num = 5;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(Num);

        for (int i = 0; i < Num - 1; i++) {
            new Thread(new RunnableOne(cyclicBarrier)).start();
        }

        Thread thread = new Thread(new RunnableTwo(cyclicBarrier));
        thread.start();
    }


    private static class RunnableOne implements Runnable {

        CyclicBarrier mCyclicBarrier;

        RunnableOne(CyclicBarrier cyclicBarrier) {
            mCyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            try {
                System.out.println("wait in barrier");
                Thread.sleep(5000);
                mCyclicBarrier.await();
                System.out.println("finish");
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

    private static class RunnableTwo implements Runnable {

        CyclicBarrier mCyclicBarrier;

        RunnableTwo(CyclicBarrier cyclicBarrier) {
            mCyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            try {
                System.out.println("wait in barrier");

                mCyclicBarrier.await(2000, TimeUnit.MILLISECONDS);

                System.out.println("finish");
            } catch (InterruptedException | BrokenBarrierException | TimeoutException e) {
                e.printStackTrace();
            }
        }
    }
}
复制代码

打印如下：

wait in barrier
wait in barrier
wait in barrier
wait in barrier
wait in barrier
java.util.concurrent.TimeoutException
	at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:257)
	at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435)
	at com.jxx.myjavatest.CyclicBarrierTest$RunnableTwo.run(CyclicBarrierTest.java:61)
	at java.lang.Thread.run(Thread.java:748)
java.util.concurrent.BrokenBarrierException
	at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
	at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
	at com.jxx.myjavatest.CyclicBarrierTest$RunnableOne.run(CyclicBarrierTest.java:40)
	at java.lang.Thread.run(Thread.java:748)
java.util.concurrent.BrokenBarrierException
	at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
	at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
	at com.jxx.myjavatest.CyclicBarrierTest$RunnableOne.run(CyclicBarrierTest.java:40)
	at java.lang.Thread.run(Thread.java:748)
java.util.concurrent.BrokenBarrierException
	at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
	at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
	at com.jxx.myjavatest.CyclicBarrierTest$RunnableOne.run(CyclicBarrierTest.java:40)
	at java.lang.Thread.run(Thread.java:748)
java.util.concurrent.BrokenBarrierException
	at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
	at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
	at com.jxx.myjavatest.CyclicBarrierTest$RunnableOne.run(CyclicBarrierTest.java:40)
	at java.lang.Thread.run(Thread.java:748)

复制代码

这里模拟了一个await()超时的异常，可以看到在抛出异常后需要我们自己处理后期的事物。同时某一个线程抛出超时异常后，其他线程再次到达会抛出BrokenBarrierException异常，防止继续等待。

Semaphore

其实Semaphore不该放到这里讲，因为Semaphore类似于Lock的存在，是对资源或者线程的一种控制，但是这篇博文主要讲了线程的等待唤起，信号量放这里讲问题也不大。

官方的说法是信号量通常用来限制线程的数量，而不是控制访问一些（物理或逻辑）资源。用法也非常简单，使用前先acquire()获取许可，在获取许可过程中，是线程是被阻塞的，使用完毕release()许可即可。这点类似于Lock，不同的是Semaphore的acquire()可以被允许多次。

Semaphore有两个构造方法，可以指定Semaphore获取是公平的还是非公平的，默认是非公平

看这里，举个栗子：

public class SemaphoreTest {

    public static void main(String[] args) {
        CountDownLatch startLatch = new CountDownLatch(1);
        Semaphore semaphore = new Semaphore(3);

        for (int i = 0; i < 10; i++) {
            new Thread(new MyRunnable(startLatch, semaphore)).start();
        }

        startLatch.countDown();
    }

    private static class MyRunnable implements Runnable {

        final CountDownLatch mCountDownLatch;
        final Semaphore mSemaphore;

        MyRunnable(CountDownLatch countDownLatch, Semaphore semaphore) {
            mCountDownLatch = countDownLatch;
            mSemaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                mCountDownLatch.await();
                mSemaphore.acquire();
                System.out.println(Thread.currentThread().getName() + " acquire success");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                mSemaphore.release();
            }
        }
    }
}
复制代码

打印如下：

Thread-0 acquire success
Thread-1 acquire success
Thread-9 acquire success
Thread-3 acquire success
Thread-2 acquire success
Thread-4 acquire success
Thread-6 acquire success
Thread-7 acquire success
Thread-5 acquire success
Thread-8 acquire success
复制代码

可以看出这是默认的非公平锁的情况，再来看一下公平锁的情况

public class SemaphoreTest {

    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3, true);

        for (int i = 0; i < 10; i++) {
            new Thread(new MyRunnable(semaphore)).start();
        }
    }

    private static class MyRunnable implements Runnable {

        final Semaphore mSemaphore;

        MyRunnable(Semaphore semaphore) {
            mSemaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                mSemaphore.acquire();
                System.out.println(Thread.currentThread().getName() + " acquire success");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                mSemaphore.release();
            }
        }
    }
}
复制代码

打印如下

Thread-0 acquire success
Thread-1 acquire success
Thread-2 acquire success
Thread-3 acquire success
Thread-4 acquire success
Thread-5 acquire success
Thread-6 acquire success
Thread-7 acquire success
Thread-8 acquire success
Thread-9 acquire success
复制代码

当然这里肯定有读者想了，直接将Semaphore置为true公平锁的情况就好了，何必去掉CountDownLatch呢。

这里需要注意下，虽然你Semaphore是公平，但是CountDownLatch到点之后唤起线程的顺序是随机的，并不一定就是线程入队的顺序唤起。

线程的join()

jion方法的作用是让主线程阻塞等待子线程完成，当然有几个前提条件，下面细说。

join方法有三个重载的版本

  1. final void join(); //一直等待到join的线程执行完毕
  2. final synchronized void join(long millis); //等待指定时间后继续执行
  3. final synchronized void join(long millis, int nanos); 同上，时间处理了一下

第一个和第三个最后其实调用的都是第二个重载方法，我们来看一下源码

    public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }
复制代码

直接看最后的while循环，可以看到，调用这个方法，其实是调用Object提供的wait(long timeout)让主线程阻塞而已。有几个注意点

  1. 子线程如果已经销毁，则直接跳过等待
  2. join(long millis) 是一个同步方位，意味着要想调用此方法需要先获取到子线程的实例对象锁

来看一个例子，验证一下第二点：

public class JoinTest {

    public static void main(String[] args) {

        final Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {

                try {
                    Thread.sleep(6000);
                    System.out.println("4---" + System.currentTimeMillis());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        thread.start();

        try {
            System.out.println("1---" + System.currentTimeMillis());
            new Thread(new MyRunnable(thread)).start();
            System.out.println("2---" + System.currentTimeMillis());
            thread.join(2000);
            System.out.println("3---" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("finish " + System.currentTimeMillis());
    }

    private static class MyRunnable implements Runnable {
        final Object mObject;

        MyRunnable(Object object) {
            mObject = object;
        }


        @Override
        public void run() {

            synchronized (mObject) {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}
复制代码

打印如下：

1---1525529803445
2---1525529803446
3---1525529807449
finish 1525529807449
4---1525529809445
复制代码

可以很清晰的看到，打印完1之后立即打印了2，但是2和3之间打相差了4秒，原因就在join之前需要先获取thread的锁对象，但是需要MyRunnable释放锁之后才能执行。

总结

好了，又到总结的时间了。

  1. CountDownLatch相对于CyclicBarrier侧重点是，等待其他线程操作完成后主线程在继续后续的操作
  2. CyclicBarrier相对于CountDownLatch侧重点是，所有的线程操作完成后等待一起继续后续操作。
  3. CountDownLatch不能重置状态，CyclicBarrier可以重置后多次利用
  4. CountDownLatch和CyclicBarrier抛出异常后都需要妥善处理
  5. Semaphore于Lock类似，主要用于线程的访问控制，构造时可以指定是否是公平竞争
  6. thread.join()主要是让主线程等待子线程执行完毕，有个注意点就是join()执行之前需要获取到子线程的实例对象锁。

转载于:https://juejin.im/post/5b9486fdf265da0ad13b5dfc

weixin_33943836
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java 线程同步 - 7种方式
Simple 专栏
02-03 3407
为何要使用同步？       java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），      将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，      从而保证了该变量的唯一性和准确性。 1.同步方法      即有synchronized关键字修饰的方法。      由于java的每个对象都有一个内置...
Java线程同步的四种方式详解
Huangjiazhen711的博客
09-28 273
当使用多个线程来访问同一个数据时，将会导致数据不准确，相互之间产生冲突，非常容易出现线程安全问题，如下图所示：比如多个线程都在操作同一数据，都打算修改商品库存，这样就会导致数据不一致的问题。线程同步的真实意思，其实是“排队”：几个线程之间要排队，一个一个对共享资源进行操作，而不是同时进行操作。所以我们用同步机制来解决这些问题，加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证了该变量的唯一性和准确性。
java多线程 门闩_详解Java多线程编程中CountDownLatch阻塞线程的方法
weixin_42515687的博客
02-26 189
直译过来就是倒计数(CountDown)门闩(Latch)。倒计数不用说，门闩的意思顾名思义就是阻止前进。在这里就是指 CountDownLatch.await() 方法在倒计数为0之前会阻塞当前线程。CountDownLatch是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。CountDownLatch 的作用和 Thread.join() 方法类似，可用...
并发编程——线程协作
你知道的越多，你不知道的越多
11-22 522
并发编程——线程协作 ​ 前面学习了线程，那么并发编程中，如何协调多个线程来开发呢？ Semaphore ​ 信号量跟前面将的同步互斥解决方案——信号量是一个东西，这是JDK的信号量实现。 源码分析 ​ 先看下JDK的Semaphore类注释，看下Semaphore是做什么的： A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each acquire blocks if necessary until
java 实现线程同步的方式有哪些
09-05
当使用多个线程来访问同一个数据时，非常容易出现线程安全问题,所以我们用同步机制来解决这些问题,本文将详细介绍，需要的朋友可以参考下
Java线程同步的四种方式详解(建议收藏)
m0_73311735的博客
09-28 1176
当使用多个线程来访问同一个数据时，将会导致数据不准确，相互之间产生冲突，非常容易出现线程安全问题，如下图所示：比如多个线程都在操作同一数据，都打算修改商品库存，这样就会导致数据不一致的问题。线程同步的真实意思，其实是“排队”：几个线程之间要排队，一个一个对共享资源进行操作，而不是同时进行操作。所以我们用同步机制来解决这些问题，加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证了该变量的唯一性和准确性。
java 多线程的同步几种方法
08-29
以下将详细解释Java中实现多线程同步的五种方法。 1. ** synchronized 关键字 ** synchronized关键字是Java中最基础的同步机制，它可以保证同一时间只有一个线程执行特定的代码块。synchronized可以应用于方法或...
基于java 线程的几种状态(详解)
08-29
基于Java线程的几种状态详解 Java线程的状态是一个复杂的概念，它们之间的转换关系也非常重要。下面我们将详细解释Java线程的六种状态：New、Runnable、Blocked、Waiting、Timed waiting和Terminated。 1. 新创建...
Java线程间的通信方式详解
09-02
本文将详细介绍两种常见的Java线程通信方式：同步和while轮询。 1. 同步（Synchronized） 同步是Java中控制线程并发的一种手段，它通过`synchronized`关键字实现。在Java中，同步主要有两种形式：同步方法（通过在...
java线程同步操作实例详解
08-27
Java线程同步操作是指在多线程编程中，为了避免线程之间的数据不一致和混乱，采取的一种机制，以确保线程安全。Java提供了多种方式来实现线程同步，包括synchronized关键字、Lock接口、Atomic变量等。 一、...
Java线程同步方法实例总结
08-27
在Java线程同步中，需要注意以下几点： 1. 使用合适的同步方法：Java提供了多种线程同步方法，开发者需要根据实际情况选择合适的同步方法。 2. 防止死锁：在使用线程同步时，需要防止死锁的出现。 3. 考虑性能问题...
java中什么是线程同步_Java线程同步的几种方式
weixin_36033417的博客
03-07 504
本文主要是介绍java中线程同步的几种常用方式。CountDownLatch从字面上理解，CountDownLatch是一个同步等待的锁，根据官方的注释可以看出这其实是一个同步执行工具类。先看一下官方注释的前两段/*** A synchronization aid that allows one or more threads to wait until* a set of operations ...
java多线程同步的四种方法_java中实现多线程的两种方法
weixin_36409041的博客
02-24 1839
java多线程有几种实现方法,都是什么?同步有几种实java中多线程的实现方法有两种：1.直接继承thread类；2.实现runnable接口；同步的实现方法有五种：1.同步方法；2.同步代码块；3.使用特殊域变量(volatile)实现线程同步；4.使用重入锁实现线程同步；5.使用局部变量实现线程同步 。JAVA多线程有哪几种实现方式JAVA多线程实现方式主要有三种：继承Thread类、实现Ru...
java中的线程同步_Java中线程同步的方法概述
weixin_28849929的博客
02-20 159
多线程编程是非常有用的，但是当使用多线程访问并修改可变资源时，如果不加控制，结果将变得难以预测造成这个问题的原因可能是因为系统线程调度的随机性，也可能是编程不当。为了确保不读取到“脏数据”，我们有必要采用一定的手段，做到线程同步。在Java中，我们大致有以下三种方法来做到线程同步：同步代码块同步方法同步锁同步代码块当有两个线程并发访问并修改同一个文件时，如果不进行线程同步，就容易造成异常。我们可以...
Java实现线程同步的五种方法
芒果就是没有盲的博客
03-08 4599
一.使用synchronized关键字 由于每个java对象都有一个内置锁，用synchronized修饰方法或者代码块时，内置锁会保护整个方法或代码块，要想执行这个方法或者代码块必须获得其内置锁，运行时会加上内置锁，当运行结束时，内置锁会打开。由于同步是一种高开销的工作，所以尽量减少同步的内容，只需同步代码块就可以。 1.修饰方法 public class Test implements Run...
java实现同步的几种方式（总结）
qq_21810059的博客
08-11 5620
1.同步方法 即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时， 内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。 代码如： public synchronized void save(){} 注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类 public class Bank { private int count =0;//账户余额 //
CountDownLatch用法
jinjin603的博客
08-23 208
官方定义：A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes. 有道翻译：一种同步辅助程序，允许一个或多个线程等待，直到在其他线程中执行的一组操作完成。 个人理解，实际就是一个倒计时计数...
Java面试篇（JVM相关专题）
最新发布
聂可以的博客
08-09 2744
Java面试篇（JVM相关专题）
详细描述Java创建多线程的几种方式
09-04
除了以上几种方式，还可以使用同步关键字synchronized或Lock对象来实现线程同步和线程间的通信，以避免线程之间的竞争条件和不一致问题。此外，Java还提供了一些高级并发类和工具，例如CountDownLatch、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值