JUC笔记（使用）

JUC笔记（使用）

三、使用

线程创建和使用

	// 第四种：使用线程池来创建线程
    @Test
    public void test04(){
        ExecutorService service = new ThreadPoolExecutor(
                2,
                Runtime.getRuntime().availableProcessors(),
                2,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3)
        );
        for (int i = 0; i < 10; i++) {
            service.submit(()->{
                System.out.println(Thread.currentThread().getName());
            });
        }

        service.shutdown();
    }

    // 第三种：实现Callable接口来实现线程创建 : 可以有返回值、进行管理
    @Test
    public void test03() throws ExecutionException, InterruptedException {
        class Test03 implements Callable<String> {
            @Override
            public String call() {
                return "1";
            }
        }
        Test03 test03 = new Test03();
        FutureTask<String> ft=new FutureTask<>(test03);
        //FutureTask实现了Runnable接口所以可以传入
        Thread t=new Thread(ft);
        t.start();
        System.out.println(ft.get());
    }

    // 第二种：实现Runable接口来实现线程创建
    @Test
    public void test02(){
        class Test02 implements Runnable{
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("执行了run方法");
                }
            }
        }
        new Thread(new Test02()).start();
    }

    // 第一种：继承Thread类来实现线程创建
    @Test
    public void test01(){
        class Test01 extends Thread{
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("执行了run方法");
                }
            }
        }
        new Test01().start();
    }

volatile关键字的使用

public class Demo01 {
    private static volatile int num = 0;

    // 三、禁止指令重排

    /**
     * 指令重排：程序运行时的样子不是你所理想型的样子，在不影响程序结果的前提下，指令执行的顺序可以进行调换。
     *
     * 初始化参数：a、b、x、y都为0
     * 指令重排前的样子：
     * 线程A：x = a；b = 1；
     * 线程B：y = b；a = 2；
     * 结果：x = 0；y = 0；
     *
     * 指令重排后的样子：
     * 线程A：b = 1；x = a；
     * 线程B：a = 2；y = b；
     * 结果：x = 2；y = 1；
     *
     */

    // 使用AtomicInteger保持原子性
    AtomicInteger atomicInteger = new AtomicInteger(0);
    // 二、不保持原子性
    @Test
    public void test02(){
        for (int i = 0; i < 10; i++) {
            new Thread(()->num++).start();
        }
        System.out.println(num);
        // 保持原子性
        for (int i = 0; i < 10; i++) {
            new Thread(()->atomicInteger.getAndIncrement()).start();
        }

        while (Thread.activeCount()>2){
            Thread.yield();
        }
        System.out.println(atomicInteger.get());

    }

    // 一、保持可见性

    /**
     * 线程有单独的工作内存
     */
    @Test
    public void test01(){
        new Thread(()-> {while(num == 0){}}).start();
        num++;
        System.out.println(num);
    }
}

Lock锁的使用

// 生产者与消费者
public class Demo01 {
    public static void main(String[] args){
        ProductionAndConsumption pac = new ProductionAndConsumption();
        for (int i = 0; i < 10; i++) {
            new Thread(()->pac.getNumber()).start();
        }
        for (int i = 10; i < 20; i++) {
            new Thread(()->pac.setNumber()).start();
        }

    }
}
class ProductionAndConsumption{
    private int number = 0;

    public Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    public void setNumber(){
        lock.lock();
        try{
            while (number == 1){
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.printf(Thread.currentThread().getName()+"\t生产\t库存: %s\n",++number);
            condition.signalAll();
        }catch(Exception e){
           e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void getNumber(){
        lock.lock();
        try{
            while (number == 0){
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.printf(Thread.currentThread().getName()+"\t消费\t\t库存: %s\n",--number);
            condition.signalAll();
        }catch(Exception e){
           e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
//		synchronized方式
//    public synchronized void setNumber(){
//        while (number == 1){
//            try {
//                wait();
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        }
//        System.out.printf(Thread.currentThread().getName()+"\t生产\t库存: %s\n",++number);
//        notifyAll();
//    }
//
//    public synchronized void getNumber(){
//        while (number == 0){
//            try {
//                wait();
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        }
//        System.out.printf(Thread.currentThread().getName()+"\t消费\t\t库存: %s\n",--number);
//        notifyAll();
//    }
}

ForkJoin的使用

public class SumTask extends RecursiveTask<Long> {
    public static void main(String[] args){
        // 创建随机数组成的数组:
        long[] array = new long[400];
        for (int i = 0; i < array.length; i++) {
            array[i] = new Random().nextInt(1000);
        }
        // fork/join task:
        ForkJoinPool fjp = new ForkJoinPool(4); // 最大并发数4
        ForkJoinTask<Long> task = new SumTask(array, 0, array.length);
        long startTime = System.currentTimeMillis();
        Long result = fjp.invoke(task);
        long endTime = System.currentTimeMillis();
        System.out.println("Fork/join sum: " + result + " in " + (endTime - startTime) + " ms.");
    }

    static final int THRESHOLD = 100;
    long[] array;
    int start;
    int end;

    SumTask(long[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        if (end - start <= THRESHOLD) {
            // 如果任务足够小,直接计算:
            long sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            System.out.println(String.format("compute %d~%d = %d", start, end, sum));
            return sum;
        }
        // 任务太大,一分为二:
        int middle = (end + start) / 2;
        System.out.println(String.format("split %d~%d ==> %d~%d, %d~%d", start, end, start, middle, middle, end));
        SumTask subtask1 = new SumTask(this.array, start, middle);
        SumTask subtask2 = new SumTask(this.array, middle, end);
        invokeAll(subtask1, subtask2);
        Long subresult1 = subtask1.join();
        Long subresult2 = subtask2.join();
        Long result = subresult1 + subresult2;
        System.out.println("result = " + subresult1 + " + " + subresult2 + " ==> " + result);
        return result;
    }
}