juc

✨知识点只说一句话系列

多线程

线程操作资源类
判断干活通知
防止线程唤醒不能if 只能while
唤醒注意标志位精准通知精准唤醒

是什么

java.util.concurrent在并发编程中使用的工具类

进程

后台运行的一个程序操作系统相关

线程

依附于进程共享进程的资源

并发

几个线程同时抢夺资源

并行

同时做不同的事情就是并行

Synchronized

锁的是整个的资源对象，如果修饰的是静态的方法锁的就会是.class的模板文件，还有就是要注意锁的对象是不是同一个

101010题目 wait notifyAll

ReentrantLock

相比Synchronized更细腻

private Lock lock = new ReentrantLock();

lock.lock();

condition.await();

lock.unlock();

condition.signalAll();

private Condition condition1 = lock.newCondition();

condition2.signal();

A 5 B10 C15

安全的集合

Set map 自己类推尝试

Vector Collections.synchronizedList copyOnwriteArrayList()

注意:ConcurrentHashMap

注意异常：ConcurrentModificationException

Callable

带返回值

class MyThread implements Callable<Integer> {

FutureTask futureTask = new FutureTask(new MyThread());
new Thread(futureTask,"dddd").start();
System.out.println(futureTask.get());

CountDownLatch

所有线程执行完- 才继续往下走

CountDownLatch countDownLatch = new CountDownLatch(7);
for (int i = 1; i <=7 ; i++) {
    new Thread(()->{
        System.out.println("go");
        countDownLatch.countDown();
    },String.valueOf(i)).start();
}
countDownLatch.await();
System.out.println("guan");

CyclicBarrier

所有线程执行完 - 执行方法中

CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
    System.out.println("手机慢了");
});

for (int i = 0; i < 7; i++) {
    int finalI = i;
    new Thread(() -> {
        try {
            System.out.println(finalI);
            cyclicBarrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }, String.valueOf(i)).start();
}

Semaphore

抢占车位

6个线程顺序执行

Semaphore semaphore = new Semaphore(1);
for (int i = 0; i < 6; i++) {
    int finalI = i;
    new Thread(()->{
        try {
            semaphore.acquire();
            System.out.println(finalI+"抢到");
            TimeUnit.SECONDS.sleep(3);
            System.out.println(finalI+"离开");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    },String.valueOf(i)).start();
}

ReentrantReadWriteLock

读写分离

class MyCache {
    private volatile Map<String, Object> map = new HashMap<>();
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    public void put(String k, Object v) {
        try {
            readWriteLock.writeLock().lock();

            System.out.println(Thread.currentThread().getName() + "开始x");
            map.put("k", "ddd");
            System.out.println(Thread.currentThread().getName() + "结束x");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }

    public void get(String k) {
        try {
            readWriteLock.readLock().lock();

            System.out.println(Thread.currentThread().getName() + "开始d");
            map.get(k);
            System.out.println(Thread.currentThread().getName() + "结束d");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

阻塞队列

不得不阻塞（火车站候车区）希望被阻塞（海底捞候客区）

空的时候取阻塞

满的时候加阻塞

add          remove      element  异常
ofter        pool        peek     true false
ofter（time） pool(time)  不可用   阻塞超时退出
put           take        不可用 阻塞

插播作用域

基本类型引用类型 String的问题（修改会在常量池创建新的）

线程池

ExecutorService executorService = Executors.newFixedThreadPool(5); //指定几个池子
//Executors.newSingleThreadExecutor() 单利
//Executors.newCachedThreadPool() 可扩容 可伸缩
    try {
        for (int i = 0; i <10 ; i++) {
            executorService.execute(()->{
                System.out.println("业务" + Thread.currentThread().getName());
            });
        }

    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        executorService.shutdown();
    }

原理：

7个重要的参数

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}

1:corePoolSize 常驻核心线程数

2:maximumPoolSize 能够容纳的最大线程数必须大于等于1

3:keepAliveTime 时间单位内没有新的来将缩小的核心线程数

4:unit 时间单位

5:workQueue 阻塞队列

6:threadFactory 生产线程工厂一般默认即可

7:reject defaultHandler 拒绝策略管控队列满了拒绝runable的策略

线程池用哪一个

newFixedThreadPool

newSingleThreadExecutor

newCachedThreadPool

哪一个都不用

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE, //最大值
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

拒绝策略

AbortPolicy 达到 直接抛出

CallerRunsPolicy 达到 谁调用的找谁  main

DiscardOldestPolicy 抛弃等待最久的

DiscardPolicy 陌陌抛弃 无法处理的 不报错

如何选择最大线程数

CPU密集核数

IO密集核数 / 阻尼

System.out.println(Runtime.getRuntime().availableProcessors());

stream计算

Function<String,Integer> fu = new Function<String, Integer>() {
    @Override
    public Integer apply(String s) {
        return 100;
    }
};

Predicate<String> predicate = new Predicate<String>() {
    @Override
    public boolean test(String s) {
        return false;
    }
};

Consumer<String>  consumer = new Consumer<String>() {
    @Override
    public void accept(String s) {

    }
};

Supplier<String> supplier =new Supplier<String>() {
    @Override
    public String get() {
        return "ddddd";
    }
}

List<Integer> list = Arrays.asList(4,6,7);
list = list.stream().map(t->{return t*2;}).collect(Collectors.toList());
for (Integer integer : list) {
    System.out.println(integer);
}


User u1 = new User(11L,"ss0",22L);
User u2 = new User(12L,"ss1",23L);
User u3 = new User(13L,"ss2",24L);
User u4 = new User(14L,"ss3",25L);
User u5 = new User(15L,"ss4",26L);

List<User> list2 = Arrays.asList(u1,u2,u3,u4,u5);



list2.stream().filter(u->{return u.getId()>=13;}).map(user -> {

    return user.getName().toUpperCase();
}).sorted((o1,o2)->{
    return o2.compareTo(o1);
}).limit(1).forEach(System.out::println);

CompletableFuture

  CompletableFuture<Void> ddd = CompletableFuture.runAsync(() -> {
  //    System.out.println("dddddd");
  });
//  System.out.println(ddd.get());

  CompletableFuture<Integer> ss = CompletableFuture.supplyAsync(()->{
     // int i = 10/0;
      return 10000;
  });



  ss.whenComplete((a,b)->{
      System.out.println("a:"+a);
      System.out.println("b:"+b);
  }).exceptionally(f->{
     return 444;
  });

  System.out.println(ss.get());

class MyTask extends RecursiveTask<Integer>{
    private static final Integer ADJUST_VALUE = 10;
    private int begin;
    private int end;
    private int result;
public MyTask(int begin, int end) {
    this.begin = begin;
    this.end = end;
}

@Override
**protected** Integer compute() {
    **if**((**end** - **begin**)<=**_ADJUST_VALUE_**){
       **for**(**int** i =**begin**;i <= **end**;i++){
            **result** = **result** + i;
       }
    }**else**{
        **int** middle = (**begin** + **end**)/2;
        MyTask task01 = **new** MyTask(**begin**,middle);
        MyTask task02 = **new** MyTask(middle+1,**end**);
        task01.fork();
        task02.fork();
        **result** =  task01.join() + task02.join();
    }
        **return result**;
}

public class  ForkJoinDemo {

public static void main(String[] args) throws ExecutionException, InterruptedException {
MyTask myTask = new MyTask(0,100);
ForkJoinPool forkJoinPool = new ForkJoinPool();
ForkJoinTask<Integer> forkJoinTask = forkJoinPool.submit(myTask);
System.out.println(forkJoinTask.get());
forkJoinPool.shutdown();
 }
}

posted @ 2020-10-23 14:32 z_先生阅读(131) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

z_先生

juc

juc

是什么

进程

线程

并发

并行