Summary of some methods of communication between java threads

Preface

In concurrent programming, we may encounter such a scenario

The A and B threads are parallel, but I want to ensure that the B thread is executed after the A thread has finished executing

This is when threads need to communicate

After A is executed, say 1 to B, feed B, I am finished

How to realize Java in Kangkang

1. Based on synchronized

2. Based on reentrantLock

3. Based on volatile

4. Based on countDownLatch

I know these four kinds at present

1. synchronized+wait () and notify ()

wait () and notify () are communication methods of Object class. Note 1: wait and notify must be used with synchronized, and wait () releases the lock, while notify () does not release the lock

public class SynchronizedTest {

 // Define a year Used to record the number of years a star has practiced 
 private static double year;

 public void run() {
  // Thread A Practice singing and dancing rap
  Thread threadA = new Thread(() -> {
   synchronized (this) {
    for (year = 0.5; year <= 5; year += 0.5) {
     System.out.println(" Cai Xuji began to practice singing and dancing rap : Practiced " + year + " Year ");
     try {
      Thread.sleep(288);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
     // As we all know, you can make your debut after two and a half years of practice 
     if (year == 2.5) {
      System.out.println("===========================> Successful practice for two and a half years, debut! ! ! ");
      this.notify();
     }
    }
   }
  });
  // Thread B Practice playing basketball 
  Thread threadB = new Thread(() -> {
   while (true) {
    synchronized (this) {
     try {
      this.wait();
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
     System.out.println(" Cai Xuji began to practice playing basketball ");
    }
   }
  });
  // Attention, 1 Be sure to start first B , or it will lead to B Never get the lock 
  threadB.start();
  threadA.start();
 }

 public static void main(String[] args) {
  SynchronizedTest test = new SynchronizedTest();
  test.run();
 }
}

Run results:

Cai Xuji began to practice singing and dancing rap: He has practiced for 0.5 years
Cai Xuji began to practice singing and dancing rap: He has practiced for 1.0 years
Cai Xuji began to practice singing and dancing rap: He has practiced for 1.5 years
Cai Xuji began to practice singing and dancing rap: He has practiced for 2.0 years
Cai Xuji began to practice singing and dancing rap: he has practiced for 2.5 years
=========================== > Successful practice for two and a half years, debut! ! !
Cai Xuji began to practice singing and dancing rap: He has practiced for 3.0 years
Cai Xuji began to practice singing and dancing rap: he has practiced for 3.5 years
Cai Xuji began to practice singing and dancing rap: He has practiced for 4.0 years
Cai Xuji began to practice singing and dancing rap: He has practiced for 4.5 years
Cai Xuji began to practice singing and dancing rap: he has practiced for 5.0 years
Cai Xuji began to practice playing basketball

Note that the thread A does not release the lock after executing notify, but starts executing the task of thread B after executing the current task

2. Based on ReentrantLock

ReentrantLock can also realize inter-thread communication, but it is a bit troublesome, so it needs to be combined with Condition of ReentrantLock

public class LockTest {
  // Define a year Used to record the number of years a star has practiced playing basketball 
  private static double year;

  public static void main(String[] args) {
   ReentrantLock lock = new ReentrantLock();
   Condition condition = lock.newCondition();
   // Thread A Practice singing and dancing rap
   Thread threadA = new Thread(() -> {
    // Lock before executing business code 
    lock.lock();
    for (year = 0.5; year <= 5; year += 0.5) {
     System.out.println(" Cai Xuji began to practice singing and dancing rap : Practiced " + year + " Year ");
     try {
      Thread.sleep(288);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
     // As we all know, you can make your debut after two and a half years of practice 
     if (year == 2.5) {
      System.out.println("===========================> Successful practice for two and a half years, debut! ! ! ");
      // Wake up a waiting thread 
      condition.signal();
     }
    }
    // Unlock after business code execution 
    lock.unlock();
   });
   // Thread B Practice playing basketball 
   Thread threadB = new Thread(() -> {
    // Lock before executing business code 
    lock.lock();
    while (true) {
     try {
      // Let the thread wait if the counter is 0 If so, it will be executed immediately 
      condition.await();
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
     System.out.println(" Cai Xu's old hen began to practice playing basketball ");
     break;
    }
    // Unlock after business code execution 
    lock.unlock();
   });
   // Attention, 1 Be sure to start first B , or it will lead to B Never get the lock 
   threadB.start();
   threadA.start();
  }
 }

Run results:

Cai Xuji began to practice singing and dancing rap: He has practiced for 0.5 years
Cai Xuji began to practice singing and dancing rap: He has practiced for 1.0 years
Cai Xuji began to practice singing and dancing rap: He has practiced for 1.5 years
Cai Xuji began to practice singing and dancing rap: He has practiced for 2.0 years
Cai Xuji began to practice singing and dancing rap: he has practiced for 2.5 years
=========================== > Successful practice for two and a half years, debut! ! !
Cai Xuji began to practice singing and dancing rap: He has practiced for 3.0 years
Cai Xuji began to practice singing and dancing rap: he has practiced for 3.5 years
Cai Xuji began to practice singing and dancing rap: He has practiced for 4.0 years
Cai Xuji began to practice singing and dancing rap: He has practiced for 4.5 years
Cai Xuji began to practice singing and dancing rap: he has practiced for 5.0 years
Cai Xu's old hen began to practice playing basketball

The effect was similar to that of synchronized+wait () and notify ()

3. Based on volatile

The use of shared variables can also be achieved, with volatile can, the principle is that multiple threads common monitoring of the same variable, according to the value of the variable changes to execute the corresponding task, here volatile is to let other threads can instantly perceive the value of the variable changes

public class volatileTest {
 // Definition 1 Shared variables, note that you must use volatile Modify 
 static volatile boolean flag = false;
 // Define a year Used to record the number of years a star has practiced playing basketball 
 private static double year;

 public static void main(String[] args) {
  // Thread A Practice singing and dancing rap
  Thread threadA = new Thread(() -> {
   while (true) {
    if (!flag) {
     for (year = 0.5; year <= 5; year += 0.5) {
      System.out.println(" Cai Xuji began to practice singing and dancing rap : Practiced " + year + " Year ");
      try {
       Thread.sleep(288);
      } catch (InterruptedException e) {
       e.printStackTrace();
      }
      // As we all know, you can make your debut after two and a half years of practice 
      if (year == 2.5) {
       System.out.println("===========================> Successful practice for two and a half years, debut! ! ! ");
       year = 0.5;
       flag = true;
       break;
      }
     }
    }
   }
  });
  // Thread B Practice playing basketball 
  Thread threadB = new Thread(() -> {
   while (true) {
    if (flag) {
     System.out.println(" Cai Xu's old hen began to practice playing basketball ");
     break;
    }
   }
  });
  // Startup thread 
  threadA.start();
  threadB.start();
 }
}

Run results:

Cai Xuji began to practice singing and dancing rap: He has practiced for 0.5 years
Cai Xuji began to practice singing and dancing rap: He has practiced for 1.0 years
Cai Xuji began to practice singing and dancing rap: he has practiced for 1.5 years
Cai Xuji began to practice singing and dancing rap: He has practiced for 2.0 years
Cai Xuji began to practice singing and dancing rap: he has practiced for 2.5 years
=========================== > Successful practice for two and a half years, debut! ! !
Cai Xu's old hen began to practice playing basketball

Based on CountDownLatch

CountDownLatch is a concurrent programming tool under JUC package, which mainly has two methods, countDown and await. CountDownLatch maintains a counter at the bottom, which is set at the time of instantiation. When calling countDown method, the counter is minus 1. If the counter is 0 before minus 1, nothing will happen. If it becomes 0 after minus 1, it will wake up all waiting threads; The await method causes the current thread to wait until the counter is 0

public class CountDownLatchTest {
 // Define a year Used to record the number of years a star has practiced playing basketball 
 private static double year;

 public static void main(String[] args) {
  CountDownLatch latch = new CountDownLatch(1);
  // Thread A Practice singing and dancing rap
  Thread threadA = new Thread(() -> {
   for (year = 0.5; year <= 5; year += 0.5) {
    System.out.println(" Cai Xuji began to practice singing and dancing rap : Practiced " + year + " Year ");
    try {
     Thread.sleep(288);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    // As we all know, you can make your debut after two and a half years of practice 
    if (year == 2.5) {
     System.out.println("===========================> Successful practice for two and a half years, debut! ! ! ");
     // Counter minus 1
     latch.countDown();
    }
   }
  });
  // Thread B Practice playing basketball 
  Thread threadB = new Thread(() -> {
   while (true) {
    try {
     // Let the thread wait if the counter is 0 If so, it will be executed immediately 
     latch.await();
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    System.out.println(" Cai Xu's old hen began to practice playing basketball ");
    break;
   }
  });
  // Startup thread 
  threadA.start();
  threadB.start();
 }
}

Run results:

Cai Xuji began to practice singing and dancing rap: He has practiced for 0.5 years
Cai Xuji began to practice singing and dancing rap: He has practiced for 1.0 years
Cai Xuji began to practice singing and dancing rap: He has practiced for 1.5 years
Cai Xuji began to practice singing and dancing rap: He has practiced for 2.0 years
Cai Xuji began to practice singing and dancing rap: He has practiced for 2.5 years
=========================== > Successful practice for two and a half years, debut! ! !
Cai Xuji began to practice singing and dancing rap: He has practiced for 3.0 years
Cai Xu's old hen began to practice playing basketball
Cai Xuji began to practice singing and dancing rap: he has practiced for 3.5 years
Cai Xuji began to practice singing and dancing rap: He has practiced for 4.0 years
Cai Xuji began to practice singing and dancing rap: He has practiced for 4.5 years
Cai Xuji began to practice singing and dancing rap: he has practiced for 5.0 years

If you run it several times, you will find that the execution timing of thread B is random, but it will always start after the counter is 0, that is to say, after the counter is 0, whoever grabs the lock of thread A and thread B will execute

In this paper, all demo can be copied and run. Everyone still needs to do more work. If you have conditions at home, you can run 1 run with idea. If you have no conditions, you can copy it by hand

Summarize