思享工具箱

Java并发（思维导图）

摘要：
i&lt；50; i&lt；}}｝查看Codepackagecom.cnblogs.mufasa.demo2；//Threadhread=新线程（实例）；（实例）；packagecom.cnblogs.mufasa.demo3；//thread2.start（）；

Java并发（思维导图）第1张

1，线程状态转换

Java并发（思维导图）第2张

无限期等待：

Java并发（思维导图）第3张

限期等待：

Java并发（思维导图）第4张

线程生命流程：

Java并发（思维导图）第5张

  

2，实现方式

 Java并发（思维导图）第6张

 代码实现样例【三种方式】：

Java并发（思维导图）第7张Java并发（思维导图）第8张
package com.cnblogs.mufasa.demo2;

import java.util.concurrent.Callable;

public class test1_Runnable implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<50;i++){
            System.out.println("当前线程："+i);
        }
    }
}

class test2_Callable implements Callable<String> {
    private int num;
    public test2_Callable(){}
    public test2_Callable(int num){
        this.num=num;
    }
    @Override
    public String call() throws Exception {
        for(int i=0;i<50;i++){
            System.out.println(this.num+"线程:"+i);
        }
        return num+"线程已完成";
    }
}

class test3_Thread extends Thread {
    private int num;
    public test3_Thread(){}
    public test3_Thread(int num){
        this.num=num;
    }
    @Override
    public void run() {
        for(int i=0;i<50;i++){
            System.out.println(this.num+"线程:"+i);
        }
    }
}
View Code
Java并发（思维导图）第9张Java并发（思维导图）第10张
package com.cnblogs.mufasa.demo2;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Client {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //实现 Runnable 接口
//        test1_Runnable instance=new test1_Runnable();
//        Thread thread=new Thread(instance);
//        Thread thread1=new Thread(instance);
//        thread.start();
//        thread1.start();

        //实现 Callable 接口
//        test2_Callable instance=new test2_Callable(1);
//        FutureTask<String> ft=new FutureTask<>(instance);
//        Thread thread = new Thread(ft);
//        test2_Callable instance1=new test2_Callable(2);
//        FutureTask<String> ft2=new FutureTask<>(instance1);
//        Thread thread1 = new Thread(ft2);
//
//        thread.start();
//        thread1.start();
//        System.out.println(ft.get());
//        System.out.println(ft2.get());

        //继承 Thread 类
        test3_Thread thread1=new test3_Thread(1);
        test3_Thread thread2=new test3_Thread(2);
        thread1.start();
        thread2.start();

    }
}
View Code
 3，基础线程机制

Java并发（思维导图）第11张

 代码实现样例：

Java并发（思维导图）第12张Java并发（思维导图）第13张
package com.cnblogs.mufasa.demo3;

public class Client1 {
    public static void main(String[] args) throws InterruptedException {

        //设置守护线程 setDaemon 伴随线程而运行
//        Thread thread1 = new Thread(new test1_Runnable(1));
//        Thread thread2 = new Thread(new test3_Thread(2));
//        thread1.setDaemon(true);
//        thread1.start();
//        thread2.start();

        //sleep Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒
        // sleep() 可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理
//        Thread thread1 = new Thread(()->{
//            try {
//                System.out.println("延迟2s");
//                Thread.sleep(2000);
//                System.out.println("延迟结束");
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        });
//        thread1.start();

//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("延迟2s");
//                try {
//                    Thread.sleep(2000);
//                    System.out.println("延迟结束");
//                    Thread.yield();//可以让出资源
//                    Thread.sleep(2000);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }finally {
//                    System.out.println("线程1运行结束");
//                }
//            }
//        }).start();
//
//        new Thread(()->{
//            try {
//                Thread.sleep(2000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }finally {
//                System.out.println("线程2延迟结束");
//            }
//        }).start();

        Thread t = new Thread(new Runnable(){
            public void run(){
                System.out.println("First task started");
                System.out.println("Sleeping for 2 seconds");
                try{
                    Thread.sleep(2000);
                } catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println("First task completed");
            }
        });
        Thread t1 = new Thread(new Runnable(){
            public void run(){
                System.out.println("Second task completed");
            }
        });
        //在t执行完毕后t1执行
        t.start(); // Line 15
        t.join(); // Line 16
        t1.start();

    }
}
View Code
4，中断

Java并发（思维导图）第14张

Java并发（思维导图）第15张Java并发（思维导图）第16张
package com.cnblogs.mufasa.demo4;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import static java.lang.Thread.interrupted;

class InterruptExample extends Thread {
    @Override
    public void run() {
        System.out.println("sleep 2s");
        try {
            Thread.sleep(2000);
            System.out.println("Thread run");
        } catch (InterruptedException e) {
            System.out.println("休眠中断");
            e.printStackTrace();
        }
    }
}

class InterruptExample1 extends Thread {
    @Override
    public void run() {
        while (!interrupted()) {
            // ..
        }
        System.out.println("Thread end");
    }
}



public class Client {
    public static void main(String[] args) {
//        InterruptExample thread1 = new InterruptExample();
//        thread1.start();
//        thread1.interrupt();
//        System.out.println("Main run");

//        InterruptExample1 thread2 = new InterruptExample1();
//        thread2.start();
//        thread2.interrupt();

//        ExecutorService executorService = Executors.newCachedThreadPool();
//        executorService.execute(() -> {
//            try {
//                Thread.sleep(2000);
//                System.out.println("Thread run");
//            } catch (InterruptedException e) {
//                System.out.println("线程程序池全体中断");
//                e.printStackTrace();
//            }
//        });
//        executorService.shutdownNow();
//        System.out.println("Main run");

        ExecutorService executorService = Executors.newCachedThreadPool();
        Future<?> future=executorService.submit(()->{
            System.out.println("3");
            while (!interrupted()){
                System.out.println("2");
            }
            System.out.println("1");
        });
        future.cancel(true);//强制中断
    }
}
View Code
5，互斥同步

 Java并发（思维导图）第17张

 代码实现：

Java并发（思维导图）第18张Java并发（思维导图）第19张
package com.cnblogs.mufasa.demo5;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class SynchronizedExample {//同步代码块，作用于同一个对象
    public void func1() {
        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        }
    }
}

class SynchronizedExample1 {//同步方法，作用于同一个对象
    public synchronized void func1() {
        for (int i = 0; i < 10; i++) {
            System.out.print(i + " ");
        }
    }
}

    class SynchronizedExample2 {//同步类，作用于整个类。
    public void func1() {
        synchronized(SynchronizedExample2.class){
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        }
    }
}

class SynchronizedExample3 {//同步静态方法，作用于整个类。
    public static synchronized void func1() {
        for (int i = 0; i < 10; i++) {
            System.out.print(i + " ");
        }
    }
}

class LockExample  {//ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁。
    private Lock lock=new ReentrantLock();
    public void func() {
        lock.lock();
        try {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        }finally {
            lock.unlock();//确保解锁，防止死锁
        }

    }
}

public class Client {
    public static void main(String[] args) {

        //synchronized-代码块  相同对象-同步代码块
//        SynchronizedExample e1=new SynchronizedExample();
//        ExecutorService executorService= Executors.newCachedThreadPool();
//        executorService.execute(()->e1.func1());
//        executorService.execute(()->e1.func1());

        //synchronized-代码块  不同对象-同步代码块,没有同步！！！
//        SynchronizedExample e1 = new SynchronizedExample();
//        SynchronizedExample e2 = new SynchronizedExample();
//        ExecutorService executorService = Executors.newCachedThreadPool();
//        executorService.execute(()->e1.func1());
//        executorService.execute(()->e2.func1());

        //synchronized-方法   不同对象,没有同步！！！
//        SynchronizedExample1 e1 = new SynchronizedExample1();
//        SynchronizedExample1 e2 = new SynchronizedExample1();
//        ExecutorService executorService = Executors.newCachedThreadPool();
//        executorService.execute(()->e1.func1());
//        executorService.execute(()->e2.func1());

        //synchronized-类   不同对象,有同步
//        SynchronizedExample2 e1 = new SynchronizedExample2();
//        SynchronizedExample2 e2 = new SynchronizedExample2();
//        ExecutorService executorService = Executors.newCachedThreadPool();
//        executorService.execute(()->e1.func1());
//        executorService.execute(()->e2.func1());

        //synchronized-静态方法   不同对象,有同步
//        SynchronizedExample3 e1 = new SynchronizedExample3();
//        SynchronizedExample3 e2 = new SynchronizedExample3();
//        ExecutorService executorService = Executors.newCachedThreadPool();
//        executorService.execute(()->e1.func1());
//        executorService.execute(()->e2.func1());

        //JDK实现的锁，作用一个对象
        LockExample lockExample = new LockExample();
        LockExample lockExample1 = new LockExample();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> lockExample.func());
//        executorService.execute(() -> lockExample1.func());
        executorService.execute(() -> lockExample.func());
    }
}
View Code
 6,线程协作

Java并发（思维导图）第20张

 样例代码：

Java并发（思维导图）第21张Java并发（思维导图）第22张
package com.cnblogs.mufasa.demo6;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class JoinExample{
    private class A extends Thread{
        @Override
        public void run(){
            for(int i=0;i<10;i++){
                System.out.println("A:"+i);
            }
        }
    }

    private class B extends Thread {
        private A a;
        B(A a) {
            this.a = a;
        }
        @Override
        public void run() {
            try {
                a.join();//先完成A线程，继续B线程
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("B");
        }
    }

    public void test() {
        A a = new A();
        B b = new B(a);
        b.start();
        a.start();
    }

}

class WaitNotifyExample{
    public synchronized void before(){
        System.out.println("before");
        notifyAll();//通知等待的线程
    }
    public synchronized void after(){
        try {
            wait();//先进行等待
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i=0;i<10;i++){
            System.out.print(i);
        }
        System.out.println("after");
    }
}

class AwaitSingalExample{
    private Lock lock=new ReentrantLock();
    private Condition condition=lock.newCondition();
    public void before(){
        lock.lock();
        try {
            System.out.println("before");
            condition.signalAll();
        }finally {
            lock.unlock();
        }
    }
    public void after(){
        lock.lock();
        try {
            condition.await();
            System.out.println("after");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

}


public class Client {
    public static void main(String[] args) {

//        JoinExample example=new JoinExample();
//        example.test();

//        ExecutorService executorService = Executors.newCachedThreadPool();
//        WaitNotifyExample example = new WaitNotifyExample();
//        WaitNotifyExample example1 = new WaitNotifyExample();
//        executorService.execute(() -> example.after());
//        executorService.execute(() -> example1.after());
//        executorService.execute(() -> example.before());
//        executorService.execute(() -> example1.before());

        ExecutorService executorService= Executors.newCachedThreadPool();
        AwaitSingalExample example=new AwaitSingalExample();
        executorService.execute(()->example.after());
        executorService.execute(()->example.before());

    }
}
View Code
7，J.U.C-AQS【java.util.concurrent】

Java并发（思维导图）第23张

样例代码：

Java并发（思维导图）第24张Java并发（思维导图）第25张
package com.cnblogs.mufasa.demo7;


import java.util.concurrent.*;

class CyclicBarrier {
    private int parties;
    private int count;
    private Runnable barrierCommand;

    public CyclicBarrier(int parties,Runnable barrierAction){
        if (parties <= 0) throw new IllegalArgumentException();
        this.parties = parties;
        this.count = parties;
        this.barrierCommand = barrierAction;
    }
    public CyclicBarrier(int parties) {
        this(parties, null);
    }
}

public class Client {
    public static void main(String[] args) throws InterruptedException {
        final int clientCount=5;
        final int totalRequestCount=10;
        Semaphore semaphore=new Semaphore(clientCount);
        ExecutorService executorService=Executors.newCachedThreadPool();
        for(int i=0;i<totalRequestCount;i++){
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    System.out.print(semaphore.availablePermits()+" ");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();
                }
            });
        }
        executorService.shutdown();




        //Semaphore
//        final int totalThread =10;
//        CyclicBarrier cyclicBarrier=new CyclicBarrier(totalThread);
//        ExecutorService executorService=Executors.newCachedThreadPool();
//        for(int i=0;i<totalThread;i++){
//            executorService.execute(()->{
//                System.out.println("before...");
//                try{
//                    cyclicBarrier.wait();//源程序是await，这里只能使用wait
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                System.out.print("after..");
//            });
//            executorService.shutdown();
//        }



        //CountDownLatch实例
//        final  int totalThread=10;
//        CountDownLatch countDownLatch=new CountDownLatch(3);
//        ExecutorService executorService= Executors.newCachedThreadPool();
//        for(int i=0;i<6;i++){
//            int finalI = i;
//            Thread.sleep(1000);
//            executorService.execute(()->{
//                System.out.print(finalI +"run-");
//                countDownLatch.countDown();
//            });
//        }
//        new Thread(()->{
//            try {
//                countDownLatch.await();
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            System.out.println("await等待线程");
//        }).start();
//
//        System.out.println("end");
//        executorService.shutdown();


    }
}
View Code
Java并发（思维导图）第26张Java并发（思维导图）第27张
package com.cnblogs.mufasa.demo7;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemaphoreExample {

    public static void main(String[] args) {
        final int clientCount = 3;
        final int totalRequestCount = 10;
        Semaphore semaphore = new Semaphore(clientCount);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < totalRequestCount; i++) {
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    System.out.print(semaphore.availablePermits() + " ");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            });
        }
        executorService.shutdown();
    }
}
View Code
8.J.U.C-其他组件

Java并发（思维导图）第28张

 样例代码：

Java并发（思维导图）第29张Java并发（思维导图）第30张
package com.cnblogs.mufasa.demo8;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

public class ForkJoinExample extends RecursiveTask<Integer> {
    private final int threshold=5;
    private int first;
    private int last;

    public ForkJoinExample(int first,int last){
        this.first=first;
        this.last=last;
    }

    @Override
    protected Integer compute() {
        int result=0;
        if(last-first<=threshold){
            //运算量足够小直接计算
            for(int i=first;i<=last;i++){
                result +=i;
            }
        }else {
            //拆分成小任务
            int middle=first+(last-first)/2;
            ForkJoinExample leftTask=new ForkJoinExample(first,middle);
            ForkJoinExample rightTask=new ForkJoinExample(middle+1,last);
            leftTask.fork();
            rightTask.fork();
            result =leftTask.join()+rightTask.join();
        }
        return result;
    }
    public static int sum(int first,int last){
        int sum=0;
        for(int i=first;i<=last;i++){
            sum+=i;
        }
        return sum;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //普通方法计算
//        System.out.println(sum(1, 1000000000));


        //并行计算方法
//        ForkJoinExample example = new ForkJoinExample(1, 1000000000);
//        ForkJoinPool forkJoinPool = new ForkJoinPool();
//        Future result=forkJoinPool.submit(example);
//        System.out.println(result.get());

    }
}
View Code
Java并发（思维导图）第31张Java并发（思维导图）第32张
package com.cnblogs.mufasa.demo8;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class FutureTaskExample{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> futureTask=new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int result=0;
                for(int i=0;i<10;i++){
                    Thread.sleep(500);
                    System.out.println("thread-A:"+i);
                    result +=i;
                }
                return result;
            }
        });
        Thread computeThread=new Thread(futureTask);
        computeThread.start();

        Thread otherThread=new Thread(()->{
            System.out.println("other task is running...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        otherThread.start();

        System.out.println("运行正常");
        System.out.println(futureTask.get());
    }
}
View Code
Java并发（思维导图）第33张Java并发（思维导图）第34张
package com.cnblogs.mufasa.demo8;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ProducerConsumer {
    private static BlockingQueue<String> queue=new ArrayBlockingQueue<>(5);
    private static class Producer extends Thread{
        @Override
        public void run() {
            try {
                queue.put("product");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(queue.size()+"produce..");
        }
    }

    private static class Consumer extends Thread{
        @Override
        public void run() {
            try {
                String product=queue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(queue.size()+"consume..");
        }
    }

    public static void main(String[] args) {//类似缓存，协调速率
        for(int i=0;i<2;i++){
            Producer producer=new Producer();
            producer.start();
        }

        for(int i=0;i<5;i++){
            Consumer consumer=new Consumer();
            consumer.start();
        }

        for (int i = 0; i < 3; i++) {
            Producer producer = new Producer();
            producer.start();
        }
    }
}
View Code
9.线程不安全

Java并发（思维导图）第35张

Java并发（思维导图）第36张Java并发（思维导图）第37张
package com.cnblogs.mufasa.demo9;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class ThreadUnsafeExample{
    private int cnt=0;
//    public synchronized void add(){//输出为1000，同步后输出正常
    public void add(){//不同步后，输出不正常
        cnt++;
    }
    public int get(){
        return cnt;
    }
}

public class Client {
    public static void main(String[] args) throws InterruptedException {
        final int threadSize=1000;
        ThreadUnsafeExample example=new ThreadUnsafeExample();
        final CountDownLatch countDownLatch=new CountDownLatch(threadSize);
        ExecutorService executorService= Executors.newCachedThreadPool();
        for(int i=0;i<threadSize;i++){
            executorService.execute(()->{
                example.add();
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println(example.get());

    }
}
View Code
10.Java内存模式

Java并发（思维导图）第38张

Java并发（思维导图）第39张Java并发（思维导图）第40张
package com.cnblogs.mufasa.demo10;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private AtomicInteger cnt=new AtomicInteger();
    public void add(){
        cnt.incrementAndGet();//原子自增
    }
    public int get(){
        return cnt.get();
    }

    public static void main(String[] args) throws InterruptedException {
        final int threadSize=1000;
        AtomicExample example=new AtomicExample();
        final CountDownLatch countDownLatch=new CountDownLatch(threadSize);
        ExecutorService excutorService= Executors.newCachedThreadPool();
        for(int i=0;i<threadSize;i++){
            excutorService.execute(()->{
                example.add();
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        excutorService.shutdown();
        System.out.println(example.get());
    }
}
View Code
Java并发（思维导图）第41张Java并发（思维导图）第42张
package com.cnblogs.mufasa.demo10;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class AtomicSynchronizedExample {
    private int cnt=0;
    public synchronized void add(){
        cnt++;
    }
    public synchronized int get(){
        return cnt;
    }

    public static void main(String[] args) throws InterruptedException {
        final int threadSize = 1000;
        AtomicSynchronizedExample example=new AtomicSynchronizedExample();
        final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for(int i=0;i<threadSize;i++){
            executorService.execute(()->{
                example.add();
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println(example.get());
    }
}
View Code
11.线程安全

Java并发（思维导图）第43张

Java并发（思维导图）第44张Java并发（思维导图）第45张
package com.cnblogs.mufasa.demo11;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerExample {
    private AtomicInteger cnt=new AtomicInteger();
    public void add(){
        cnt.incrementAndGet();
    }
    public int get(){
        return cnt.get();
    }

    public static void main(String[] args) throws InterruptedException {
        AtomicIntegerExample example=new AtomicIntegerExample();
        ExecutorService executorService= Executors.newCachedThreadPool();
        for(int i=0;i<10;i++){
            executorService.execute(()->example.add());
        }
        Thread.sleep(100);
        example.add();
        System.out.println(example.get());
        executorService.shutdown();

    }

}
View Code
Java并发（思维导图）第46张Java并发（思维导图）第47张
package com.cnblogs.mufasa.demo11;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class ImmutableExample {
    public static void main(String[] args) {
        Map<String,Integer> map=new HashMap<>();
        map.put("b",2);
        System.out.println(map.get("b"));
        Map<String,Integer> unmodifiableMap= Collections.unmodifiableMap(map);//相当于设置一下
        System.out.println(unmodifiableMap.get("b"));
        unmodifiableMap.put("a",1);
    }
}
View Code
Java并发（思维导图）第48张Java并发（思维导图）第49张
package com.cnblogs.mufasa.demo11;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Stack_closedExample {
    public void add100() {
        int cnt=0;
        for(int i=0;i<100;i++){
            cnt++;
        }
        System.out.println(cnt);
    }

    public static void main(String[] args) {
        Stack_closedExample example=new Stack_closedExample();
        ExecutorService executorService= Executors.newCachedThreadPool();
        executorService.execute(()->example.add100());
        executorService.execute(()->example.add100());
        executorService.shutdown();
    }
}
View Code
Java并发（思维导图）第50张Java并发（思维导图）第51张
package com.cnblogs.mufasa.demo11;

public class ThreadLocalExample {

    public static void main(String[] args) {
        ThreadLocal threadLocal=new ThreadLocal();
        Thread thread1=new Thread(()->{
            threadLocal.set(1);
            try{
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(threadLocal.get());
            threadLocal.remove();
        });
        Thread thread2=new Thread(()->{
            threadLocal.set(2);
            threadLocal.remove();
        });
        thread1.start();
        thread2.start();
    }
}
View Code
Java并发（思维导图）第52张Java并发（思维导图）第53张
package com.cnblogs.mufasa.demo11;

public class ThreadLocalExample1 {
    public static void main(String[] args) {
        ThreadLocal threadLocal1=new ThreadLocal();
        ThreadLocal threadLocal2=new ThreadLocal();
        Thread thread1 = new Thread(() -> {
            threadLocal1.set(1);
            threadLocal2.set(1);
        });
        Thread thread2 = new Thread(() -> {
            threadLocal1.set(2);
            threadLocal2.set(2);
        });
        thread1.start();
        thread2.start();
    }
}
View Code
12.锁优化

Java并发（思维导图）第54张

Java并发（思维导图）第55张Java并发（思维导图）第56张
package com.cnblogs.mufasa.demo12;

public class StringExample {
    public static String concatString(String s1, String s2, String s3) {
        return s1 + s2 + s3;
    }
    public static String concatString1(String s1, String s2, String s3) {
        StringBuilder  sb = new StringBuilder ();
        sb.append(s1);
        sb.append(s2);
        sb.append(s3);
        return sb.toString();
    }

    public static void main(String[] args) {
        System.out.println(concatString("12","34","56"));
        System.out.println(concatString1("12","34","56"));
    }
}
View Code
13.多线程开发良好的实践

Java并发（思维导图）第57张

 https://blog.csdn.net/StefanTimber/article/details/73823689

https://github.com/CyC2018/CS-Notes/blob/master/notes/Java%20%E5%B9%B6%E5%8F%91.md

标签：#println#线程#System#amp#gt | 浏览：143 | 发布日期：

免责声明：文章转载自《Java并发（思维导图）》仅用于学习参考。如对内容有疑问，请及时联系本站处理。

上篇生产环境中使用Docker Swarm的一些建议skywalking agent部署spring boot项目问题记录下篇

宿迁高防，2C2G15M，22元/月；香港BGP，2C5G5M，25元/月 雨云优惠码：MjYwNzM=

相关文章

多线程中的lua同步问题

最近写paintsnow::start时出现了一个非常麻烦的BUG，程序的Release版本大约每运行十几次就会有一次启动时崩溃（Debug版本还没崩溃过），崩溃点也不固定。经过简单分析之后，确定是线程同步的问题。于是便修改了线程通信的代码，并使用pthread_mutex_lock/unlock来防止冲突。重新编译后，崩溃频率有所减少。但是每运行约四十次...

Win10 右键选项报错“找不到应用程序”及选项清除的处理

状况如图： 安装HFS或其他软件时，会在右键选项中自动增加该软件的关联方式， 但卸载后，又无法清除。如图所示。 清除方法如下： 1.Win+R，输入命令：regedit  2.选择 编辑 >>> 查找 ，输入关键词进行查找    3.或者输入路径：计算机HKEY_CLASSES_ROOTDirectoryShellExContext...

MindManager Pro 9.1.157更改默认字体

新创建图表内默认字体 打开MindManager模型存放目录：C:\Documents and Settings\（用户名）\Local Settings\Application Data\Mindjet\MindManager\9\Library\ENU\Templates\，打开New Blank Map.mmat此文件，在“Central Topi...

Android SurfaceView

一、SurfaceView简介SurfaceView可以在主线程之外的线程中向屏幕绘图上。这样可以避免画图任务繁重的时候造成主线程阻塞，从而提高了程序的反应速度。在游戏开发中多用到SurfaceView，游戏中的背景、人物、动画等等尽量在画布canvas中画出。什么是Surface在这里要先说说什么是Surface。简单的说Surface对应了一块屏幕缓冲...

eclipse导入maven项目有红叉及pom.xml出错的问题的解决

导入我们的项目的时候总会出现很多红叉，看着很难受，其实可以解决的(本人使用方法一解决)解决方法：1、先build project，然后右键项目->maven->update projectpom还是有问题就到这个目录，打开命令行,mvn clean->mvn eclipse:clean->mvn eclipse:eclipse 基本...

C# 主线程 辅助线程

主线程：就是UI线程；从主线程通过Thread.Start或AsyncDelegate.BeginEnvoke（可带参数、定义回调方法、避免轮询）将进入辅助线程；采用异步的方式调用委托可以在界面重绘时避免工作线程被阻塞；从主线程中调用委托的AsyncDelegate.EndEnvoke方法将进入辅助线程（EndInvoke()是阻塞方法，在回调方法中调用E...

最新文章

随机推荐

思享工具箱导航