Five implementation methods for converting asynchronous calls to synchronization in Java

 public class ProducerConsumerExample {
     private static final int BUFFER_SIZE = 5;
     private final Object lock = new Object();
     private int[] buffer = new int[BUFFER_SIZE];
     private int count = 0;
 
     // Producer thread     public void produce() throws InterruptedException {
         int value = 0;
         while (true) {
             synchronized (lock) {
                 while (count == BUFFER_SIZE) {
                     ("The buffer is full, the producer is waiting...");
                     ();
                 }
                 buffer[count++] = value++;
                 ("Production Data: " + value + ", Number of buffers: " + count);
                 ();
             }
             (1000);
         }
     }
 
     // Consumer thread     public void consume() throws InterruptedException {
         while (true) {
             synchronized (lock) {
                 while (count == 0) {
                     ("The buffer is empty, the consumer is waiting...");
                     ();
                 }
                 int value = buffer[--count];
                 ("Consumption Data: " + value + ", Number of buffers: " + count);
                 ();
             }
             (1500);
         }
     }
 
     public static void main(String[] args) {
         ProducerConsumerExample example = new ProducerConsumerExample();
     
         // Start producer and consumer threads         new Thread(example::produce).start();
         new Thread(example::consume).start();
     }
 }

 import ;
 import ;
 
 public class TestReentrantLock4 {
     static ReentrantLock lock = new ReentrantLock();
     static Condition moneyCondition = ();
     static Condition ticketCondition = ();
     static boolean haveMoney = false;
     static boolean haveTicket = false;
 
     public static void main(String[] args) throws InterruptedException {
         // Farmer 1 (waiting for money)         new Thread(() -> {
             ();
             try {
                 while (!haveMoney) {
                     ("Farmer 1 is waiting for funds...");
                     ();
                 }
                 ("Farmer 1 gets the funds and goes home!");
             } finally {
                 ();
             }
         }, "Farmer1").start();
 
         // Farmer 2 (wait for tickets)         new Thread(() -> {
             ();
             try {
                 while (!haveTicket) {
                     ("Farmer 2 is waiting for the ticket...");
                     ();
                 }
                 ("Farmer 2 gets the ticket and goes home!");
             } finally {
                 ();
             }
         }, "Farmer2").start();
 
         // Main thread simulates the issuance conditions         (1000);
         ();
         try {
             haveMoney = true;
             ();
             ("Funds have been issued!");
 
             haveTicket = true;
             ();
             ("Tickets have been issued!");
         } finally {
             ();
         }
     }
 }

 import .*;
 
 public class FutureExample {
     public static void main(String[] args) {
         ExecutorService executor = ();
 
         Future<Integer> future = (() -> {
             int sum = 0;
             for (int i = 1; i <= 100; i++) {
                 sum += i;
                 (10);
             }
             return sum;
         });
 
         ("The main thread performs other tasks...");
     
         try {
             Integer result = (2, );
             ("Calculation results: 1+2+...+100 = " + result);
         } catch (TimeoutException e) {
             ("Calculation timeout!");
             (true);
         } catch (Exception e) {
             ();
         } finally {
             ();
         }
     }
 }

 import ;
 import ;
 import ;
 
 public class CountDownLatchExample {
     private static final int RUNNERS = 5;
     private static final CountDownLatch startSignal = new CountDownLatch(1);
     private static final CountDownLatch readySignal = new CountDownLatch(RUNNERS);
 
     public static void main(String[] args) throws InterruptedException {
         ExecutorService executor = (RUNNERS);
 
         for (int i = 1; i <= RUNNERS; i++) {
             (() -> {
                 try {
                     ("athlete" + i + "Preparing...");
                     (300);
                     ();
 
                     ();
                     ("athlete" + i + "Start!");
                 
                     ((long)(() * 1000));
                     ("athlete" + i + "Get the end!");
                 } catch (InterruptedException e) {
                     ();
                 }
             });
         }
 
         ("The referee waits for the athlete to take his seat...");
         ();
         ("\nAll athletes are in place!");
 
         (1);
         ("The starting gun fires!");
         ();
 
         ();
         (5, );
         ("\nThe match is over!");
     }
 }

 import ;
 import ;
 
 public class CyclicBarrierExample {
     private static final CyclicBarrier barrier = 
         new CyclicBarrier(3, () -> ("\n===== Entering the next stage ====="));
 
     public static void main(String[] args) {
         for (int i = 1; i <= 3; i++) {
             new Thread(new TeamMember(i)).start();
         }
     }
 
     static class TeamMember implements Runnable {
         private int id;
 
         public TeamMember(int id) {
              = id;
         }
 
         @Override
         public void run() {
             try {
                 doWork("Demand Analysis", 1000);
                 ();
             
                 doWork("Development coding", 1500);
                 ();
             
                 doWork("Test Deployment", 800);
                 ();
             } catch (Exception e) {
                 ();
             }
         }
 
         private void doWork(String phase, int baseTime) throws InterruptedException {
             int time = baseTime + (int)(() * 500);
             ("%s Complete %s(%dms)\n", 
                 ().getName(), phase, time);
             (time);
         }
     }
 }