JUC

于 2020-12-21 17:30:38 发布
阅读量130 收藏
点赞数
分类专栏： java修炼之路——java基础

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

package com.juc;

public class SynchronizedTest {
    public static void main(String[] args) {
        Ticker ticker = new Ticker();
            new Thread(()->{
                for (int i = 0; i < 50; i++) {
                    ticker.sale();
                }
            },"A").start();
            new Thread(()->{
                for (int i = 0; i < 50; i++) {
                    ticker.sale();
                }
            },"B").start();
            new Thread(()->{
                for (int i = 0; i < 50; i++) {
                    ticker.sale();
                }
            },"C").start();

    }
}

class Ticker{
    int num = 50;
    public synchronized void sale(){
        if(num>0){
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(num--)+"票");
        }
    }

}

在这里插入图片描述
在这里插入图片描述

package com.juc;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockTest{
    public static void main(String[] args) {
        Ticker1 ticker = new Ticker1();
        new Thread(()->{
            for (int i = 0; i < 50; i++) {
                ticker.sale();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 50; i++) {
                ticker.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 50; i++) {
                ticker.sale();
            }
        },"C").start();

    }
}

class Ticker1{
    int num = 50;
    Lock lock = new ReentrantLock();
    public synchronized void sale(){
        lock.lock();
        try {
            if(num>0){
                System.out.println(Thread.currentThread().getName()+"卖出了第"+(num--)+"票");
            }
        }finally {
            lock.unlock();
        }

    }

}

在这里插入图片描述
在这里插入图片描述

package com.juc.pc;

public class PcDemo01 {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }
        },"B").start();
    }
}

class Data {
    int num = 0;
    public synchronized void increment(){
        if(num!=0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        num ++;
        System.out.println(num);
        this.notifyAll();

    }

    public synchronized void decrement(){
        if(num==0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        num --;
        System.out.println(num);
        this.notifyAll();

    }
}

在这里插入图片描述

package com.juc.pc;

public class PcDemo01 {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        },"C").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }
        },"D").start();
    }
}

class Data {
    int num = 0;
    public synchronized void increment(){
        while(num!=0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        num ++;
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        this.notifyAll();

    }

    public synchronized void decrement(){
        while(num==0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        num --;
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        this.notifyAll();

    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

package com.juc.pc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class PcLockDemo01{
    public static void main(String[] args) {
        Data1 data = new Data1();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        },"C").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }
        },"D").start();
    }
}

class Data1 {
    int num = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    public void increment(){
        lock.lock();
        try {
            while(num!=0){
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            num ++;
            System.out.println(Thread.currentThread().getName()+"=>"+num);
            condition.signalAll();
        }finally {
            lock.unlock();
        }


    }

    public  void decrement(){
        lock.lock();
        try {
            while(num==0){
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            num --;
            System.out.println(Thread.currentThread().getName()+"=>"+num);
           condition.signalAll();
        }finally {
            lock.unlock();
        }


    }
}

在这里插入图片描述

package com.juc.pc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//A-》B-》c-》A
public class ConditionHxDemo {
    public static void main(String[] args) {
        Data3 data3 = new Data3();
        new Thread(()->{
            for (int i = 0; i < 10; i++) data3.printA();
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++)  data3.printB();
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++)  data3.printC();
        },"C").start();
    }
}

class Data3{
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int num = 1;
    public void printA(){
        lock.lock();
        try {
            while(1!=num){
                try {
                    condition1.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"====>AAAA");
            num = 2;
            condition2.signal();
        }finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try {
            while(2!=num){
                try {
                    condition2.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"====>BBBB");
            num = 3;
            condition3.signal();
        }finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
            while(3!=num){
                try {
                    condition3.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"====>CCCC");
            num = 1;
            condition1.signal();
        }finally {
            lock.unlock();
        }
    }
}

8锁

在这里插入图片描述

package com.juc.bLock;

import java.util.concurrent.TimeUnit;

/**
 * 1.标准情况下先发短信还是打电话？发短信
 * 因为锁的存在，
 * synchronized锁的对象是方法的调用者
 * 两个方法用的是同一个锁
 * 所以谁先拿到锁谁先执行
 */
public class BLock01 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendSms();
        }).start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone.call();
        }).start();
    }
}


class Phone{
    public  synchronized void sendSms(){
        System.out.println("发短信");
    }

    public  synchronized void call(){
        System.out.println("打电话");
    }
}

package com.juc.bLock;

import java.util.concurrent.TimeUnit;

/**
 * 2.发短信延迟4秒，先发短信还是先打电话？ 发短信
 *
 */
public class BLock02 {
    public static void main(String[] args) throws InterruptedException {
        Phone1 phone = new Phone1();
        new Thread(()->{
            phone.sendSms();
        }).start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone.call();
        }).start();
    }
}


class Phone1{
    public  synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public  synchronized void call(){
        System.out.println("打电话");
    }
}

package com.juc.bLock;

import java.util.concurrent.TimeUnit;

/**
 * 3.增加一个普通方法后先执行发短信还是hello？ hello
 * hello方法没有加锁，所以不受锁的印象
 */
public class BLock03 {
    public static void main(String[] args) throws InterruptedException {
        Phone2 phone = new Phone2();
        new Thread(()->{
            phone.sendSms();
        }).start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone.hello();
        }).start();
    }
}


class Phone2{
    public  synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public  synchronized void call(){
        System.out.println("打电话");
    }

    public void hello(){
        System.out.println("hello");
    }
}

package com.juc.bLock;

import java.util.concurrent.TimeUnit;

/**
 * 4、两个对象两个同步方法，先执行发短信还是先执行发短信？ 打电话
 * synchronized锁的对象是方法的调用者
 * 两个不同的对象有两把锁
 */
public class BLock04 {
    public static void main(String[] args) throws InterruptedException {
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();
        new Thread(()->{
            phone1.sendSms();
        }).start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone2.call();
        }).start();
    }
}


class Phone3{
    public  synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public  synchronized void call(){
        System.out.println("打电话");
    }
}

package com.juc.bLock;

import java.util.concurrent.TimeUnit;

/**
 * 5.先发短信还是先打电话 发短信
 * static静态方法，类一下加载就有了是一个class模板，Phone4只有唯一一个class对象（反射）
 * synchronized锁的是class对象
 */
public class BLock05 {
    public static void main(String[] args) throws InterruptedException {
        Phone4 phone = new Phone4();
        new Thread(()->{
            phone.sendSms();
        }).start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone.call();
        }).start();
    }
}


class Phone4{
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call(){
        System.out.println("打电话");
    }
}

package com.juc.bLock;

import java.util.concurrent.TimeUnit;

/**
 * 6.先发短信还是先打电话？ 发短信
 * static静态方法，类一下加载就有了是一个class模板，Phone5只有唯一一个class对象（反射）
 * synchronized锁的是class对象
 */
public class BLock06 {
    public static void main(String[] args) throws InterruptedException {
        Phone5 phone1 = new Phone5();
        Phone5 phone2 = new Phone5();
        new Thread(()->{
            phone1.sendSms();
        }).start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone2.call();
        }).start();
    }
}


class Phone5{
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call(){
        System.out.println("打电话");
    }
}

package com.juc.bLock;

import java.util.concurrent.TimeUnit;

/**
 * 7、先发短信还是先打电话？ 打电话
 * 两把锁，static一个锁的是class模板， 一个是锁的事class对象
 */
public class BLock07 {
    public static void main(String[] args) throws InterruptedException {
        Phone6 phone = new Phone6();
        new Thread(()->{
            phone.sendSms();
        }).start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone.call();
        }).start();
    }
}


class Phone6{
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }
}

package com.juc.bLock;

import java.util.concurrent.TimeUnit;

/**
 * 先打电话还是先发短信？ 打电话
 */
public class BLock08 {
    public static void main(String[] args) throws InterruptedException {
        Phone7 phone1 = new Phone7();
        Phone7 phone2 = new Phone7();
        new Thread(()->{
            phone1.sendSms();
        }).start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone2.call();
        }).start();
    }
}


class Phone7{
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }
}

在这里插入图片描述

package com.juc.collection;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * java.util.ConcurrentModificationException 并发修改异常
 * 并发下ArrayList不安全
 *
 * 解决方案：
 * 1、List<String> list = new Vector<String>(); Vector是安全的
 * 2、Collections.synchronizedList()
 * 3、juc包下 new CopyOnWriteArrayList<>()
 *
 *
 * CopyOnWrite：写入时复制，cow 计算机程序设计领域的一种优化
 * 多个线程调用的时候，List，读取的时候内容是固定的，写入（覆盖）
 * 在写入的时候避免覆盖造成数据问题，所以先复制一份，之后再覆盖
 * 读写分离
 * CopyOnWriteArrayList比Vector好在哪里？ CopyOnWriteArrayList用的lock锁，Vector用的是synchronized锁
 */
public class ListTest {
    public static void main(String[] args) {
        List<String> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

set不安全
在这里插入图片描述

package com.juc.collection;

import java.util.*;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * java.util.ConcurrentModificationException
 * 解决方法：
 * 1、Collections.synchronizedSet(new HashSet<String>())
 * 2、new CopyOnWriteArraySet<>()
 */
public class SetTest {
    public static void main(String[] args) {
//        Set<String> set = new HashSet<String>();
//        Set<String> set = Collections.synchronizedSet(new HashSet<String>());
        Set<String> set = new CopyOnWriteArraySet<>();
        for (int i = 0; i < 1000; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package com.juc.callable;

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

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyThread thread = new MyThread();
        FutureTask futureTask = new FutureTask(thread);
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();//只打印了一个call(),结果会缓存，提高效率
        System.out.println(futureTask.get());//可能产生阻塞，一般放在最后或者异步通信
    }
}
class MyThread implements Callable<String>{

    @Override
    public String call() throws Exception {
        System.out.println("call()");
        return "1024";
    }
}

结果会缓存，提高效率
可能产生阻塞，一般放在最后或者异步通信

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
8.2 CyclicBarrier
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
限流
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package com.juc.rw;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCacheLock myCache = new MyCacheLock();
        for (int i = 0; i < 5; i++) {
            final int templ = i;
            new Thread(()->{
                myCache.put(templ+"",templ);
            }).start();
        }

        for (int i = 0; i < 5; i++) {
            final int templ = i;
            new Thread(()->{
                myCache.get(templ+"");
            }).start();
        }
    }
}

class MyCache{
    private volatile Map<String,Object> map = new HashMap<>();
    
    public void put(String key,Object value){
        System.out.println(Thread.currentThread().getName()+"=>写入"+key);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+"=>写入ok");
    }
    
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"=>读取"+key);
        map.get(key);
        System.out.println(Thread.currentThread().getName()+"=>读取ok");
    }
}

class MyCacheLock{
    private volatile Map<String,Object> map = new HashMap<>();
    private ReadWriteLock readWriteLock = new  ReentrantReadWriteLock();

    public void put(String key,Object value){
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"=>写入"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"=>写入ok");
        }finally {
            readWriteLock.writeLock().unlock();
        }

    }

    public void get(String key){
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"=>读取"+key);
            map.get(key);
            System.out.println(Thread.currentThread().getName()+"=>读取ok");
        }finally {
            readWriteLock.readLock().unlock();
        }

    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package com.juc.bq;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

public class Test {

    public static void main(String[] args) throws InterruptedException {
        test4();
    }

    public static  void test1(){
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);
        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));
//        System.out.println(blockingQueue.add("d")); 多出指定的长度会抛出异常Queue full
        System.out.println("==========================");
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
//        System.out.println(blockingQueue.remove());会抛出异常java.util.NoSuchElementException

    }

    public static  void test2(){
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
        System.out.println(blockingQueue.offer("d"));
        System.out.println("==========================");
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());

    }


    public static  void test3() throws InterruptedException {
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);
        blockingQueue.put("a");
        blockingQueue.put("b");
        blockingQueue.put("c");
//        blockingQueue.put("d"); 阻塞
        System.out.println("==========================");
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());

    }

    public static  void test4() throws InterruptedException {
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
        System.out.println(blockingQueue.offer("d",2, TimeUnit.SECONDS));
        System.out.println("==========================");
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll(2, TimeUnit.SECONDS));

    }
}

在这里插入图片描述

package com.juc.bq;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/**
 * 只能放入一个元素，只有这个元素被去除才能放入其他元素
 */
public class SynchronousQueueDemo {
    public static void main(String[] args) {
        BlockingQueue<String> blockingQueue =new SynchronousQueue<>();
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+" put 1");
                blockingQueue.put("1");
                System.out.println(Thread.currentThread().getName()+" put 2");
                blockingQueue.put("2");
                System.out.println(Thread.currentThread().getName()+" put 3");
                blockingQueue.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1").start();

        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"=>"+blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"=>"+blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"=>"+blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t2").start();
    }
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package com.juc.forkjoin;

import java.util.concurrent.RecursiveTask;

/**
 * 如何使用ForkJoin
 * 1、forkJoinPool 通过它执行
 * 2、forkJoinPool.execute(ForkJoinTask task)
 * 3、计算类要继承 ForkJoinTask
 */
public class ForkJoinDemo extends RecursiveTask<Long> {
    private Long start;
    private Long end;
    //临界值
    private Long temp = 10000L;

    public ForkJoinDemo(Long start, Long end, Long temp) {
        this.start = start;
        this.end = end;
        this.temp = temp;
    }

    public ForkJoinDemo(Long start, Long end) {
        this.start = start;
        this.end = end;
    }


    /**
     * The main computation performed by this task.
     *
     * @return the result of the computation
     */
    @Override
    protected Long compute() {
        if(end-start<temp){
            Long sum =0L;
            for (Long i =start;i<end;i++){
                sum+=1;
            }
           return sum;
        }else{
            Long middle = (start+end)/2;
            ForkJoinDemo task1 = new ForkJoinDemo(start,middle);
            task1.fork();//拆分任务把线程压入队列
            ForkJoinDemo task2 = new ForkJoinDemo(middle,end);
            task2.fork();
            return task1.join() + task2.join();
        }
    }
}


package com.juc.forkjoin;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        test1();//8716
//        test2();//7926
          test3();//250
    }
    public static void test1(){
        long start = System.currentTimeMillis();
        Long sum =0L;
        for (Long i =1l;i<10_0000_0000l;i++){
            sum+=1;
        }
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+"  时间："+(end-start));

    }
    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(1l,10_0000_0000l);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);
        Long sum = submit.get();
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+"  时间："+(end-start));
    }
    public static void test3(){
        long start = System.currentTimeMillis();
        Long sum = LongStream.rangeClosed(1l,10_0000_0000l).parallel().reduce(0,Long::sum);
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+"  时间："+(end-start));
    }
}

在这里插入图片描述

package com.juc.future;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class Demo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(()->{
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "CompletableFuture<Void>");
        });
        completableFuture.get();//阻塞获取执行的结果
        System.out.println(Thread.currentThread().getName());
    }
}


package com.juc.future;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class Demo02 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "CompletableFuture<Integer>");
            int i= 1/0;
            return 1024;
        });
        System.out.println(12);//率先输出
        System.out.println( completableFuture.whenComplete((t,u)->{
            System.out.println("t=>"+t);//返回正常结果
            System.out.println("u=>"+u);//错误信息
        }).exceptionally((e)->{
            System.out.println(e.getMessage());
            return 233; // 返回错误结果
        }).get());


    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

树》》》新时代码农
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC2019.6V1.5.zip
10-29
juc笔记：这些知识点是怎么积累进来的呢，下面我以JUC的学习过程为例子来讲解我的知识框架图记录过程， 首先我们知道，JUC就是java.util.concurrent包，俗称java并发包，那首先我们要知道java并发包是用来干嘛 的...
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
Java——JUC
12-29
用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;包含下载地址
JUC思维导图.emmx
01-29
个人整理的JUC知识总结
JUC线程高级
02-27
JUC线程高级,
狂神说JUC代码狂神说JUC代码
09-11
狂神说JUC代码
狂神说JUC.pdf
05-02
Bilibili狂神老师的JUC课程笔记，讲的非常的好，希望大家结合视频学习狂神老师的JUC编程，精进自己的技术。
这就是标题—— JUC.pdf
05-19
JUC是什么 线程 进程 / 线程 线程状态 wait / sleep 并发 / 并行 Lock 使用Lock锁 可重入锁 公平锁 / 非公平锁 Synchronized / Lock 线程通讯 wait()、notify()和notifyAll() 虚假唤醒 Condition 定制化通信 多线程...
JUC底层讲解，面试可用。
10-09
juc面试总结，很详细，，校招冲刺可以看一下
JUC并发编程.md
01-28
JUC并发编程学习笔记，狂神说
JUC学习笔记 .md
01-31
JUC学习笔记 .md
juc详解juc详解juc详解juc详解juc详解juc详解juc详解
08-02
juc详解juc详解juc详解juc详解juc详解
尚硅谷Java视频_JUC 视频教程
02-17
尚硅谷_JUC线程高级_源码、课件　·1. 尚硅谷_JUC线程高级_volatile 关键字与内存可见性 ·2. 尚硅谷_JUC线程高级_原子变量与 CAS 算法 ·3. 尚硅谷_JUC线程高级_模拟 CAS 算法 ·4. 尚硅谷_JUC线程高级_同步容器类...
JUC AQS的加解锁.pdf
02-25
本资源描述了Java并发常见的问题AQS的加锁解锁的过程
JUC线程锁框架
12-31
JUC线程锁框架深度解析，包含整套视频和源码以及开发文档。
juc2
02-09
juc2
heima-JUC-资料
04-25
heima-JUC-资料
用AIDA模型，分析知乎、小红书和Facebook的广告效果.docx
最新发布
06-02
用AIDA模型，分析知乎、小红书和Facebook的广告效果.docx
java juc面试
10-06
Java JUC（Java Util Concurrent）是Java并发编程中的一个重要模块，提供了一系列的工具类和API，用于实现高效的并发编程。 Java JUC包括了以下几个核心组件： 1. 锁：Java提供了多种锁机制来实现并发编程，例如...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值