Shulou(Shulou.com)06/02 Report--

This article will explain in detail how to achieve multithreaded circular printing in Java. The editor thinks it is very practical, so I share it for you as a reference. I hope you can get something after reading this article.

Wait-notify

The problem of circular printing can be solved by setting the target value. Each thread wants to print the target value, and if the number it wants this time after getting the lock is not what it wants, it will enter the wait.

Class Wait_Notify_ABC {private int num; private static final Object Lock = new Object (); private void print_ABC (int target) {synchronized (Lock) {/ / circularly print for (int I = 0; I

< 10; i++) { while (num % 3 != target) { try { Lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } num++; System.out.print(Thread.currentThread().getName()); Lock.notifyAll(); } } } public static void main(String[] args) { Wait_Notify_ABC wait_notify_abc = new Wait_Notify_ABC(); new Thread(() ->

{wait_notify_abc.print_ABC (0);}, "A") .start (); new Thread (()-> {wait_notify_abc.print_ABC (1);}, "B") .start (); new Thread (()-> {wait_notify_abc.print_ABC (2);}, "C") .start () }}

The print 1-100 problem can be understood to mean that there is a global counter that records which number is currently printed, and the rest is the same as the problem of printing ABC in a loop.

Class Wait_Notify_100 {private int num; private static final Object LOCK = new Object (); private int maxnum = 100; private void printABC (int targetNum) {while (true) {synchronized (LOCK) {while (num% 3! = targetNum) {if (num > = maxnum) {break } try {LOCK.wait ();} catch (InterruptedException e) {e.printStackTrace ();}} if (num > = maxnum) {break } num++; System.out.println (Thread.currentThread (). GetName () + ":" + num); LOCK.notifyAll ();}} public static void main (String [] args) {Wait_Notify_100 wait_notify_100 = new Wait_Notify_100 () New Thread (()-> {wait_notify_100.printABC (0);}, "thread1"). Start (); new Thread (()-> {wait_notify_100.printABC (1);}, "thread2") .start (); new Thread (()-> {wait_notify_100.printABC (2) }, "thread3") .start ();}} join mode

Calling the join () method of another thread in one thread allows another thread to jump the queue. For example, if A.join () is called in the Main method, cpu will execute the task in thread A, and then see if Main can grab the running right. So for ABC, we can tell B to jump the queue and C to jump the queue.

Class Join_ABC {static class printABC implements Runnable {private Thread beforeThread; public printABC (Thread beforeThread) {this.beforeThread = beforeThread;} @ Override public void run () {if (beforeThread! = null) {try {beforeThread.join () } catch (InterruptedException e) {e.printStackTrace ();}} System.out.print (Thread.currentThread (). GetName ());}} public static void main (String [] args) throws InterruptedException {for (int I = 0; I

< 10; i++) { Thread t1 = new Thread(new printABC(null), "A"); Thread t2 = new Thread(new printABC(t1), "B"); Thread t3 = new Thread(new printABC(t2), "C"); t1.start(); t2.start(); t3.start(); Thread.sleep(100); } }}ReentrantLock 同理，synchronized和reentrantlock都是我们常用的加锁方式，不过后者可以中断，可以实现公平锁，可以使用condition…但是需要我们手动释放锁。jdk8后二者性能差不多，毕竟synchronized有锁升级的过程嘛。 class ReentrantLock_ABC { private int num; private Lock lock = new ReentrantLock(); private void printABC(int targetNum) { for (int i = 0; i < 100; ) { lock.lock(); if (num % 3 == targetNum) { num++; i++; System.out.print(Thread.currentThread().getName()); } lock.unlock(); } } public static void main(String[] args) { Lock_ABC lockABC = new Lock_ABC(); new Thread(() ->

{lockABC.printABC (0);}, "A"). Start (); new Thread (()-> {lockABC.printABC (1);}, "B"). Start (); new Thread (()-> {lockABC.printABC (2);}, "C"). Start ();}} ReentrantLock+Condition

In the above way, if the thread finds that it cannot execute the task after grabbing the lock, it will be released, and then other threads will preempt it and see if it is their own. This method is time-consuming. If we can implement a precise wake-up lock, that is, A wakes up its next one, B, after completing the task, then our Condition will be used.

Class ReentrantLock_Condition_ABC {private int num; private static Lock lock = new ReentrantLock (); private static Condition C1 = lock.newCondition (); private static Condition c2 = lock.newCondition (); private static Condition c3 = lock.newCondition (); private void printABC (int targetNum, Condition currentThread, Condition nextThread) {for (int I = 0; I

< 100; ) { lock.lock(); try { while (num % 3 != targetNum) { currentThread.await(); //阻塞当前线程 } num++; i++; System.out.print(Thread.currentThread().getName()); nextThread.signal(); //唤醒下一个线程 } catch (Exception e) { e.printStackTrace(); } finally { lock.unlock(); } } } public static void main(String[] args) { ReentrantLock_Condition_ABC reentrantLockConditionAbc = new ReentrantLock_Condition_ABC(); new Thread(() ->

{reentrantLockConditionAbc.printABC (0, C1, c2);}, "A"). Start (); new Thread (()-> {reentrantLockConditionAbc.printABC (1, c2, c3);}, "B"). Start (); new Thread ()-> {reentrantLockConditionAbc.printABC (2, c3, C1);}, "C"). Start ();}} Semaphore

Have you guys ever thought of how many ways we can implement it in the producer-consumer model? Wait\ notify,ReentrantLock,Semaphone, blocking queue, pipe input / output stream.

The right one is Semaphone.

Semaphore has acquire method and release method. When the acquire method is called, the thread is blocked until the license is obtained. A license is added to the Semaphore when the release method is called. If there is no thread that obtained the license, Semaphore simply records the number of licenses available.

Precise wake-up can also be achieved using Semaphore.

Class SemaphoreABC {private static Semaphore S1 = new Semaphore (1); / / because thread An is executed first, the counter of S1 is set to 1 private static Semaphore S2 = new Semaphore (0); private static Semaphore S3 = new Semaphore (0); private void printABC (Semaphore currentThread, Semaphore nextThread) {for (thread I = 0; I)

< 10; i++) { try { currentThread.acquire(); //阻塞当前线程，即信号量的计数器减1为0 System.out.print(Thread.currentThread().getName()); nextThread.release(); //唤醒下一个线程，即信号量的计数器加1 } catch (InterruptedException e) { e.printStackTrace(); } } } public static void main(String[] args) throws InterruptedException { SemaphoreABC printer = new SemaphoreABC(); new Thread(() ->

{printer.printABC (S1, S2);}, "A"). Start (); Thread.sleep (100); new Thread (()-> {printer.printABC (S2, S3);}, "B"). Start (); Thread.sleep (100); new Thread (()-> {printer.printABC (S3, S1)) }, "C"). Start ();}} this is the end of the article on "how to achieve multithreaded circular printing in Java". I hope the above content can be of some help to you, so that you can learn more knowledge. if you think the article is good, please share it for more people to see.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.