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

This article mainly shows you "how to use Java.util.concurrent", the content is easy to understand, clear, hope to help you solve your doubts, the following let the editor lead you to study and learn "how to use Java.util.concurrent" this article.

Java8 online API https://blog.fondme.cn/apidoc/jdk-1.8-google/

Package com.shi.juc;import java.util.concurrent.atomic.AtomicInteger;/** @ author shiye * * II. Atomic variable: after jdk1.5 The commonly used atomic variable * 1 is provided under the java.util.concurrent.atomic package. Volatile ensures visibility * 2. CAS (Compare-and-swap) algorithm ensures the atomicity of data * CAS algorithm is hardware support for concurrent operations sharing data * CAS contains three operands: * memory value V * pre-estimate (old value) A * update value B * if and only if the value is not available. Assign the value of B to V, otherwise, do nothing * / public class AtomacTest {public static void main (String [] args) {AtomicThread thread = new AtomicThread () For (int I = 0; I

< 10; i++) { new Thread(thread).start(); } }}class AtomicThread implements Runnable{ public AtomicInteger auAtomicInteger = new AtomicInteger(); public int add() { return auAtomicInteger.getAndIncrement(); } @Override public void run() { System.out.println(add()); } }

Package com.shi.juc;import java.util.Iterator;import java.util.concurrent.CopyOnWriteArrayList;/** * CopyOnWriteArrayList/CopyOnWriteArraySet (write and copy) * Note: it is inefficient to add for a long time, because it will be copied each time it is added, which is very expensive. * you can choose to use this for concurrent iterative reads to improve efficiency * @ author shiye * * / public class CopyOnWriteArrayListTest {public static void main (String [] args) {HelloEntity entity = new HelloEntity (); for (int I = 0; I)

< 10; i++) { new Thread(()->

{entity.forEachList ();}, String.valueOf (I). Start ();}} class HelloEntity {private static CopyOnWriteArrayList list = new CopyOnWriteArrayList (); static {list.add ("aaa") List.add ("bbb"); list.add ("ccc");} public void forEachList () {Iterator iterator = list.iterator (); while (iterator.hasNext ()) {System.out.println (Thread.currentThread (). GetName () + "thread" + iterator.next ()) List.add ("DDD"); / / add data} when reading again

Package com.shi.juc;import java.util.concurrent.CountDownLatch;/** * CountDownLatch: lock * @ author shiye * * / public class TestCountDownLatch {public static void main (String [] args) throws InterruptedException {/ / Lock final CountDownLatch latch = new CountDownLatch (10) / / start time long start = System.currentTimeMillis (); / * start 10 threads and allow an even number of 1000 cycles per thread to calculate the total time spent * / for (int I = 0; I)

< 10; i++) { new Thread( ()->

{synchronized (latch) {for (int j = 0; j {System.out.println) For (int I = 0; I

< 10; i++) { new Thread(()->

{System.out.println (Thread.currentThread (). GetName () + "\ t set to Dragon Ball."); try {cyclicBarrier.await () / / it must be placed at the bottom} catch (InterruptedException e) {e.printStackTrace ();} catch (BrokenBarrierException e) {e.printStackTrace () }, String.valueOf (I)) .start ();}

Package com.shi.juc;import java.util.concurrent.Semaphore;/** * simulates 6 cars to seize 3 parking spaces * @ author shiye * * results: Thread-2 grabs parking spaces, pauses 3 seconds Thread-0 grabs parking spaces, pauses 3 seconds Thread-1 grabs parking spaces, pauses 3 seconds Thread-1 to leave parking spaces. Thread-2 leaves the parking space. Thread-0 leaves the parking space. Thread-3 grabs parking space, pauses 3 seconds Thread-5 grabs parking spaces, pauses 3 seconds Thread-4 grabs parking spaces, pauses 3 seconds Thread-4 to leave parking spaces. Thread-5 leaves the parking space. Thread-3 leaves the parking space. * / public class TestSemaphore {public static void main (String [] args) {/ / simulate 3 parking spaces false: unfair Semaphore semaphore = new Semaphore (3, false); for (int I = 0; I

< 6; i++) { new Thread(()->

{try {semaphore.acquire (); / / preemptive parking space (preemptive thread) System.out.println (Thread.currentThread () .getName () + "preemptive parking space, pause for 3 seconds") Thread.sleep (3000); System.out.println (Thread.currentThread (). GetName () + "leave the parking space.");} catch (InterruptedException e) {e.printStackTrace () } finally {semaphore.release (); / / release parking spaces (release threads)}}, "Thread -" + I) .start ();}

Package com.shi.juc;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;/** * one. The third way to create a thread is to implement the Callalbe interface. Compared to the Runable interface, the method returns a value and can throw an exception. * two. You can use * @ author shiye * * / public class TestCallable {public static void main (String [] args) throws InterruptedException, ExecutionException {CallableDemo td = new CallableDemo (); / / execute Callable mode as a lock, which requires the support of the FutureTask implementation class to receive the operation result FutureTask result = new FutureTask (td). New Thread (result) .start (); / / receives the result of execution System.out.println ("- the current thread starts -"); Integer sum = result.get () / / getting the current value will cause all execution of the current thread to be suspended until it is obtained (with caution) System.out.println ("and:" + sum); System.out.println ("- the current thread terminates -") }} / * @ author shiye * create a thread and provide a return value * / class CallableDemo implements Callable {@ Override public Integer call () throws Exception {int sum = 0; for (int I = 0; I)

< Integer.MAX_VALUE; i++) { sum+=i; } Thread.sleep(10000); return sum; } }/** * 实现Runable接口的方式实现的结果class RunableThread implements Runnable{ @Override public void run() { }}*/ package com.shi.juc;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * 用于解决线程同步的问题 * Synchronized：隐士锁 * 1. 同步代码块 * 2. 同步方法 * * JDK 1.5 以后 * 3.同步锁 : Lock * 注意： 是一个显示锁，需要通过Lock()方法上锁， 必须通过 unlock() 解锁（放在finnal中最好） * * @author shiye * */public class TestLock { static int toket = 100; public static void main(String[] args) { Lock lock = new ReentrantLock(); /** * 创建10个线程去卖票 */ for (int i = 0; i < 10; i++) { new Thread(()->

{while (toket > 0) {lock.lock () / / locked try {if (toket > 0) {Thread.sleep System.out.println (Thread.currentThread (). GetName () + "thread is selling tickets, remaining" + (--toket)) }} catch (InterruptedException e) {e.printStackTrace () } finally {lock.unlock () / / unlock}, String.valueOf (I)) .start ();}

Package com.shi.juc;/** * synchronized using hermit locks * producer-consumer problems: * guarantee that the goods produced by producers can be consumed even if they are consumed (there is no surplus) * @ author shiye * * / public class TestProductAndConsoumer {public static void main (String [] args) {Clerk clerk = new Clerk (); Productor pro = new Productor (clerk) Consumer con = new Consumer (clerk); new Thread (pro, "producer A"). Start (); new Thread (con, "Consumer B"). Start (); new Thread (pro, "producer C"). Start () New Thread (con, "Consumer D"). Start ();}} / / salesperson class Clerk {private int product = 0; / / purchase public synchronized void get () throws InterruptedException {while (product > = 1) {System.out.println (Thread.currentThread (). GetName () + ": product is full!") ; this.wait (); / / wait () method must be put into the loop to avoid false awakening problem} System.out.println (Thread.currentThread (). GetName () + "purchase:" + (+ + product)); this.notifyAll () } / / selling public synchronized void sale () throws InterruptedException {while (product=1) {/ / cycle is to avoid false awakening problem System.out.println (Thread.currentThread (). GetName () + ": product is full!") ; condition.await (); / thread waiting} System.out.println (Thread.currentThread (). GetName () + "purchase:" + (+ + product)); condition.signalAll () / / Wake up} finally {lock.unlock (); / / unlock}} / / sell goods public void sale () throws InterruptedException {try {lock.lock () / / Lock while (product {while (true) {demo.printA ();}}, "Amur1") .start () / / B new Thread (()-> {while (true) {demo.printB ();}}, "Bmer1") .thread () / / C new Thread (()-> {while (true) {demo.printC ();}}, "Cmur1") .thread () System.out.println ("- second round thread -"); / / thread A new Thread (()-> {while (true) {demo.printA ()) }}, "start 2"). Start (); / / Thread B new Thread (()-> {while (true) {demo.printB ()) }}, "start 2"). Start (); / / Thread C new Thread (()-> {while (true) {demo.printC ()) }}, "Cmur2"). Start ();}} class AlternateDemo {private int number = 1 handle / the flag of the current thread executing thread private Lock lock = new ReentrantLock (); / / displays the lock private Condition condition1 = lock.newCondition (); / / Communication between threads private Condition condition2 = lock.newCondition () Private Condition condition3 = lock.newCondition (); / / print A public void printA () {lock.lock () / / Lock try {while (number! = 1) {/ / must use while not if because: thread false wake up, thread preemption problem condition1.await (); / Thread A waits} for (int I = 0; I)

< 1; i++) { System.out.println(Thread.currentThread().getName() + " : 打印 "+ i + " 遍 "); } number = 2; condition2.signal();//唤醒2线程 } catch (Exception e) { e.printStackTrace(); }finally { lock.unlock();//解锁 } } //打印B public void printB() { lock.lock();//上锁 try { while(number != 2) {//一定要用while 不能要if 因为：存在线程线程虚假唤醒，线程抢占的问题 condition2.await(); } for (int i = 0; i < 1; i++) { System.out.println(Thread.currentThread().getName() + " : 打印 "+ i + " 遍 "); } number = 3; condition3.signal();//唤醒3线程 } catch (Exception e) { e.printStackTrace(); }finally { lock.unlock();//解锁 } } //打印C public void printC() { lock.lock();//上锁 try { while(number != 3) {//一定要用while 不能要if 因为：存在线程线程虚假唤醒，线程抢占的问题 condition3.await(); } for (int i = 0; i < 1; i++) { System.out.println(Thread.currentThread().getName() + " : 打印 "+ i + " 遍 "); } number = 1; condition1.signal();//唤醒1线程 } catch (Exception e) { e.printStackTrace(); }finally { lock.unlock();//解锁 } } } package com.shi.juc;import java.time.LocalTime;import java.util.concurrent.locks.ReadWriteLock;import java.util.concurrent.locks.ReentrantReadWriteLock;/** * 读写锁 * 写写/读写 需要互斥 * 读读 不需要互斥 * @author shiye * * 结果： 完全证明上面的理论成功 read-0 正在读 0 当前时间：14:47:47.534 read-1 正在读 0 当前时间：14:47:47.534 write-0 写过之后的值为: 111 当前时间：14:47:52.535 write-1 写过之后的值为: 111 当前时间：14:47:57.536 write-2 写过之后的值为: 111 当前时间：14:48:02.536 read-2 正在读 111 当前时间：14:48:07.537 read-3 正在读 111 当前时间：14:48:07.537 write-3 写过之后的值为: 111 当前时间：14:48:12.537 write-5 写过之后的值为: 111 当前时间：14:48:17.537 * */public class TestReadAndWrite { public static void main(String[] args) { ReadAndWrite item = new ReadAndWrite(); //启动100个读写线程操作数据 for (int i = 0; i < 10; i++) { //读线程 new Thread(()->

{item.read ();}, "read-" + I) .start (); / / write thread new Thread (()-> {item.write () }, "write-" + I) .start ();} class ReadAndWrite {private int number = 0; private ReadWriteLock readWriteLock = new ReentrantReadWriteLock (); / / read-write lock / / read public void read () {readWriteLock.readLock () .lock () / / read lock try {Thread.sleep (5000); / / Sleep for 5 seconds System.out.println (Thread.currentThread () .getName () + "reading" + number + "current time:" + LocalTime.now ()) } catch (InterruptedException e) {e.printStackTrace ();} finally {readWriteLock.readLock () .unlock () / / release read lock}} / / write public void write () {readWriteLock.writeLock () .lock (); try {number = 111; Thread.sleep (5000) / / it takes 5 seconds to write System.out.println (Thread.currentThread (). GetName () + "the value after writing is:" + number+ "current time:" + LocalTime.now ());} catch (Exception e) {e.printStackTrace () } finally {readWriteLock.writeLock () .unlock ();}

Package com.shi.juc;/** * thread 8 lock * @ author shiye * * 1. Two common synchronization methods, two threads, standard printing, printing? / / one two * 2. Add Thread.sleep () to getOne () and print? / / one two * 3. Add ordinary getThree (), print? / / Three one two * 4. Two common synchronization methods, two Number objects print? / / two one * 5. Modify getOne () to a static synchronization method, a Number object? / / two one * 6. Modify both methods to be static synchronization methods, a Number object? / / one two * 7. One static synchronization method, one non-static synchronization method, two Number?//two one * 8. Two static synchronization methods, two Number objects? / / one two * * the key to thread eight locks: * one. The default of the non-static method lock is this, and the static method lock is the corresponding Class strength * 2. Only one thread can hold a lock at a time, no matter how many methods. * * / public class TestThread8Lock {public static void main (String [] args) {Number number = new Number (); Number number2 = new Number (); / / Thread 1 new Thread (()-> {number.getOne ();}) .start () / / Thread 2 new Thread (()-> {/ / number.getTwo (); number2.getTwo ();}) .start () / / new Thread / new Thread (()-> {/ / number.getThree (); / /}) .start ();}} class Number {public static synchronized void getOne () {try {Thread.sleep (3000) } catch (InterruptedException e) {e.printStackTrace ();} System.out.println ("one");} public static synchronized void getTwo () {System.out.println ("two") } / / public void getThree () {/ / System.out.println ("Three"); / /}}

Package com.shi.juc;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;/** * 1. Thread pool: provides a thread queue in which all threads in waiting states are stored. The extra overhead of creation and destruction is avoided and the response speed is improved. * * II. Architecture of thread pool: * java.util.concurrent.Executor: root interface responsible for thread usage and scheduling * |-* * ExecutorService subinterface: main interface of thread pool * |-- ThreadPoolExecutor thread pool implementation class * |-- ScheduledExecutorService subinterface: responsible for thread scheduling * |-- ScheduledThreadPoolExecutor: inherits ThreadPoolExecutor Implement ScheduledExecutorService * * 3. Tool class: Executors * ExecutorService newFixedThreadPool (): create a fixed size thread pool * ExecutorService newCachedThreadPool (): cache thread pool. The number of thread pools is not fixed, and the number can be changed automatically according to needs. * ExecutorService newSingleThreadExecutor (): create a single thread pool. There is only one thread in the thread pool * * ScheduledExecutorService newScheduledThreadPool (): create fixed-size threads that can delay or schedule tasks. * @ author shiye * * / public class TestThreadPool {public static void main (String [] args) throws InterruptedException, ExecutionException {Number1 number1 = new Number1 (); / / 1 create a 5-thread thread pool ExecutorService pool = Executors.newFixedThreadPool (5) / / 2 create 10 threads to execute threads / / result: each thread must execute one by one sequentially, and one thread must return the value to execute the next thread (lock) for (int I = 0; I)

< 10; i++) { Future future = pool.submit(()->

{int sum = number1.sum (); return sum;}); Integer sum = future.get () The result of System.out.println (Thread.currentThread (). GetName () + "thread execution is" + sum);} / / 3 create 10 threads to execute threads / / results, each thread does not need to wait too much to operate separately, for (int I = 0; I)

< 10; i++) { pool.submit(()->

{number1.sum ();});} pool.shutdown () / / be sure to close the thread pool}} / * calculate the sum of 1-100s * @ author shiye * * / class Number1 {public int sum () {try {Thread.sleep (1000);} catch (InterruptedException e) {e.printStackTrace () } int sum = 0; for (int I = 0; I

< 101; i++) { sum +=i; } System.out.println(Thread.currentThread().getName()+ " 线程 执行的结果为： " + sum); return sum; }} package com.shi.juc;import java.util.Random;import java.util.concurrent.ExecutionException;import java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.ScheduledFuture;import java.util.concurrent.TimeUnit;/** * ScheduledExecutorService newScheduledThreadPool() : 创建固定大小的线程，可以延迟或定时的执行任务。 * @author shiye * */public class TestScheduledThreadPool { public static void main(String[] args) throws InterruptedException, ExecutionException { //1 创建一个带任务调度的线程池 ScheduledExecutorService pool = Executors.newScheduledThreadPool(5); for (int i = 0; i < 10; i++) { //启动一个任务调度 ScheduledFuture future = pool.schedule(()->

{int num = new Random (). NextInt (100); System.out.println (Thread.currentThread (). GetName () + "the random number generated by the thread is:" + num); return num;}, 3PowerTimeUnit. Seconds) / / delay 3 s to create a thread System.out.println (future.get ());} pool.shutdown (); / / close thread pool}}

The above is all the contents of this article "how to use Java.util.concurrent". Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

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.