【JavaSE】之JUC并发编程（上）

最新推荐文章于 2023-07-12 14:03:25 发布
最新推荐文章于 2023-07-12 14:03:25 发布
阅读量2.2k 收藏 6
点赞数 6
分类专栏： JavaSE 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42146402/article/details/127272865
版权

【JavaSE】JUC并发编程

前言

本文为JUC并发编程相关知识，Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~

一、JUC概述

JUC指的是Java的并发工具包，包含以下三个包：

  • java.util.concurrent
  • java.util.concurrent.atomic：支持原子型操作
  • java.util.concurrent.locks：lock锁

二、进程与线程

1.进程

  • 程序执行的一次过程，一个进程包含一个或多个线程。进程是资源分配的单位。

2.线程

  • 可以指程序执行过程中，负责实现某个功能的单位。线程是CPU调度和执行的单位。

3.并发

  • 同一时刻，多个线程交替执行。（一个CPU交替执行线程）。

4.并行

  • 同一时刻，多个线程同时执行。（多个CPU同时执行多个线程）。
# 获取cpu的核数（cpu密集型；io密集型）
System.out.println(Runtime.getRuntime().availableProcessors());

5.并发编程的本质

  • 并发编程的本质是充分利用cpu资源。

三、多线程回顾

1.线程的几种状态

    public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
         // 新生
        NEW,
        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
         // 运行
        RUNNABLE,
        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
         // 阻塞
        BLOCKED,
        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
         // 等待，死死的等待
        WAITING,
        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
         // 超时等待
        TIMED_WAITING,
        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
         // 终止
        TERMINATED;
    }

2.sleep和wait的区别

  • sleep是Thread类的本地方法；wait是Object类的方法。
  • sleep不释放锁；wait释放锁。
  • sleep不需要和synchronized关键字一起使用；wait必须和synchronized代码块一起使用。
  • sleep不需要被唤醒（时间到了自动退出阻塞）；wait需要被唤醒。
  • sleep一般用于当前线程休眠，或者轮循暂停操作；wait则多用于多线程之间的通信。

四、Lock锁

1.传统的synchronized

synchronized中文意思是同步，也称之为”同步锁“。
synchronized的作用是保证在同一时刻， 被修饰的代码块或方法只会有一个线程执行，以达到保证并发安全的效果。
synchronized是Java中解决并发问题的一种最常用的方法，也是最简单的一种方法。
在JDK1.5之前synchronized是一个重量级锁，相对于j.u.c.Lock，它会显得那么笨重，随着Javs SE 1.6对synchronized进行的各种优化后，synchronized并不会显得那么重了。

synchronized的作用主要有三个：

  • 原子性：确保线程互斥地访问同步代码；
  • 可见性：保证共享变量的修改能够及时可见，其实是通过Java内存模型中的“对一个变量unlock操作之前，必须要同步到主内存中；如果对一个变量进行lock操作，则将会清空工作内存中此变量的值，在执行引擎使用此变量前，需要重新从主内存中load操作或assign操作初始化变量值”来保证的；
  • 有序性：有效解决重排序问题，即 “一个unlock操作先行发生(happen-before)于后面对同一个锁的lock操作”；

2.公平锁和非公平锁（锁的底层）

公平锁：十分公平，不能插队。
非公平锁：十分不公平，可以插队。（默认非公平锁）

3.Lock锁

Lock锁是一个接口，他有三个实现类：

  • ReentrantLock类
  • ReentrantReadWriteLock.ReadLock
  • ReentrantReadWriteLock.WriteLock

4.Lock锁和synchronized的区别

  • Synchronized是内置Java关键字；Lock是一个Java类。
  • Synchronized无法判断获取锁的状态；Lock可以判断是否获取到了锁。（boolean b = lock.tryLock();）
  • Synchronized会自动释放锁；Lock必须要手动释放锁，如果不释放锁，死锁。
  • Synchronized线程1获得锁阻塞时，线程2会一直等待下去；Lock锁线程1获得锁阻塞时，线程2等待足够长的时间后中断等待，去做其他的事。
  • Synchronized可重入锁，不可以中断的，非公平；Lock，可重入锁，可以判断锁，非公平（可以自己设置）。
    lock.lockInterruptibly();方法：当两个线程同时通过该方法想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。
  • Synchronized适合锁少量的代码同步问题；Lock适合锁大量的同步代码。

5.生产消费者

生产者和消费者问题：synchronized版

public class Demo04 {
 public static void main(String[] args) {
     Data data = new Data();
     new Thread(() -> {
         for (int i = 0; i < 10; i++) {
             try {
                 data.increment();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }, "A").start();
     new Thread(() -> {
         for (int i = 0; i < 10; i++) {
             try {
                 data.decrement();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }, "B").start();
 }
}
// 判断等待，业务，通知
class Data {
 private int i = 0;
 // +1
 public synchronized void increment() throws InterruptedException {
     if (i != 0) {
         this.wait();
     }
     i++;
     System.out.println(Thread.currentThread().getName() + "=>" + i);
     // 通知其他线程我+1完成
     this.notifyAll();
 }
 // -1
 public synchronized void decrement() throws InterruptedException {
     if (i==0){
         this.wait();
     }
     i--;
     System.out.println(Thread.currentThread().getName() + "=>" + i);
     // 通知其他线程，我-1完毕
     this.notifyAll();
 }
}

问题存在：A、B、C、D四个线程！虚假唤醒问题
if改成while解决虚假唤醒

 public class Demo04 {
     public static void main(String[] args) {
         Data data = new Data();
         new Thread(() -> {
             for (int i = 0; i < 10; i++) {
                 try {
                     data.increment();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         }, "A").start();
         new Thread(() -> {
             for (int i = 0; i < 10; i++) {
                 try {
                     data.decrement();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         }, "B").start();
         new Thread(() -> {
             for (int i = 0; i < 10; i++) {
                 try {
                     data.increment();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         }, "C").start();
         new Thread(() -> {
             for (int i = 0; i < 10; i++) {
                 try {
                     data.decrement();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         }, "D").start();
     }
 }
 // 判断等待，业务，通知
 class Data {
     private int i = 0;
     // +1
     public synchronized void increment() throws InterruptedException {
         while (i != 0) {
             this.wait();
         }
         i++;
         System.out.println(Thread.currentThread().getName() + "=>" + i);
         // 通知其他线程我+1完成
         this.notifyAll();
     }
     // -1
     public synchronized void decrement() throws InterruptedException {
         while (i==0){
             this.wait();
         }
         i--;
         System.out.println(Thread.currentThread().getName() + "=>" + i);
         // 通知其他线程，我-1完毕
         this.notifyAll();
     }
 }

生产者和消费者问题：JUC版

public class Demo04 {
 public static void main(String[] args) {
     Data data = new Data();
     new Thread(() -> {
         for (int i = 0; i < 10; i++) {
             try {
                 data.increment();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }, "A").start();
     new Thread(() -> {
         for (int i = 0; i < 10; i++) {
             try {
                 data.decrement();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }, "B").start();
     new Thread(() -> {
         for (int i = 0; i < 10; i++) {
             try {
                 data.increment();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }, "C").start();
     new Thread(() -> {
         for (int i = 0; i < 10; i++) {
             try {
                 data.decrement();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }, "D").start();
 }
}
// 判断等待，业务，通知
class Data {
 private int i = 0;
 Lock lock = new ReentrantLock();
 Condition condition = lock.newCondition();
 // +1
 public  void increment() throws InterruptedException {
     lock.lock();
     try {
         while (i != 0) {
             condition.await();
         }
         i++;
         System.out.println(Thread.currentThread().getName() + "=>" + i);
         // 通知其他线程我+1完成
         condition.signalAll();
     } catch (InterruptedException e) {
         e.printStackTrace();
     } finally {
         lock.unlock();
     }
 }
 // -1
 public void decrement() throws InterruptedException {
     lock.lock();
     try {
         while (i==0){
             condition.await();
         }
         i--;
         System.out.println(Thread.currentThread().getName() + "=>" + i);
         // 通知其他线程，我-1完毕
         condition.signalAll();
     } catch (InterruptedException e) {
         e.printStackTrace();
     } finally {
         lock.unlock();
     }
 }
}

6.Condition实现精准通知唤醒

public class Demo05 {
    public static void main(String[] args) {
        Data01 data01 = new Data01();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data01.A();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data01.B();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data01.C();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();
    }
}
// 判断等待，业务，通知
//A执行完调用B，B执行完调用C，C执行完调用A
class Data01 {
    private int num = 1;// 1A 2B 3C
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    public void A() throws InterruptedException {
        lock.lock();
        try {
            // 业务代码，判断=>执行=>通知！
            while (num!=1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>AAAAA");
            num = 2;
            // 唤醒指定的线程，B
            condition2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void B() throws InterruptedException {
        lock.lock();
        try {
            while (num!=2){
                condition2.await();
            }
            num = 3;
            System.out.println(Thread.currentThread().getName()+"=>BBBBB");
            // 唤醒指定的线程，C
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void C() throws InterruptedException {
        lock.lock();
        try {
            while (num!=3){
                condition3.await();
            }
            num = 1;
            System.out.println(Thread.currentThread().getName()+"=>CCCCC");
            // 唤醒指定的线程，A
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

五、8锁现象

六、不安全集合类

1.ArryList集合

多线程下不安全；可能会报错：java.util.ConcurrentModificationException（并发修改异常）

// java.util.ConcurrentModificationException：并发修改异常
public class Test11 {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                strings.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(strings);
            }).start();
        }
    }
}

解决方案：

  • List list = new Vector<>();
  • List strings = Collections.synchronizedList(new
    ArrayList<>());
  • List strings = new CopyOnWriteArrayList<>();

2.HashSet集合

HashSet集合的底层是hashmap的key；多线程下不安全；可能会报错：java.util.ConcurrentModificationException（并发修改异常）

// java.util.ConcurrentModificationException：并发修改异常
public class Test11 {
    public static void main(String[] args) {
        // Set<String> strings = Collections.synchronizedSet(new HashSet<>());
        HashSet<String> strings = new HashSet<>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                strings.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(strings);
            }).start();
        }
    }
}

解决方案：

  • Set strings = Collections.synchronizedSet(new HashSet<>());
  • Set strings = new CopyOnWriteArraySet<>();

3.HashMap集合

多线程下不安全；可能会报错：java.util.ConcurrentModificationException（并发修改异常）

// java.util.ConcurrentModificationException：并发修改异常
public class Test11 {
    public static void main(String[] args) {
        // 默认相当于
        Map<String, String> map = new HashMap<>(16, 0.75F);
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            }).start();
        }
    }
}

解决方案：

  • 使用Map<String, String> concurrentHashMap = new ConcurrentHashMap<>();

七、Callable接口

Callable接口类似于Runnable接口，是线程第三种创建方式，有以下特点：

  • 可以抛出异常。
  • 可以有返回值。
  • 方法不同与Runnable接口。用的是Call方法。
public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask futureTask = new FutureTask(new MyThread());// 适配类
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();// 打印一个Call，结果会被缓存，提高效率
        Integer s = (Integer) futureTask.get();// get方法可能会产生阻塞
        System.out.println(s);
    }
}
class MyThread implements Callable<Integer>{
    @Override
    public Integer call(){
        System.out.println("Call");
        return 1024;
    }
}

八、常用辅助类

1.CountDownLatch

应用场景：

  • 多线程任务汇总。
  • 多线程任务阻塞住，等待发令枪响，一起执行。

每次有线程调用，数量-1，当计数器归零，countDownLatch.await()就会被唤醒向下执行。

// 计数器
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        // 总数是6，必须要是执行任务的时候使用
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"=>Go Out");
                countDownLatch.countDown();// 数量-1
            }).start();
        }
        countDownLatch.await();// 等待计数器归零，然后再往下执行
        System.out.println("关门");
    }
}

// 打印：
// Thread-0=>Go Out
// Thread-5=>Go Out
// Thread-4=>Go Out
// Thread-2=>Go Out
// Thread-3=>Go Out
// Thread-1=>Go Out
// 关门

2.CyclicBarrier

应用场景：允许一组线程全部等待彼此达到共同屏障点的同步辅助。

// 相当于加法计数器
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        // 集齐七颗龙珠召唤神龙
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {// 如果计数器为7，线程只有6个，则会等待，不进行召唤神龙
            System.out.println("召唤神龙");
        });
        for (int i = 0; i < 7; i++) {
            final int temp = i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "收集" + temp + "个龙珠！");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

3.Semaphore

Semaphore：信号量

public class SemaphoreDemo {
    public static void main(String[] args) {
        // 线程数量：停车位！限流
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire();// 得到
                    System.out.println(Thread.currentThread().getName()+"抢到车位！");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开车位！");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();// 释放
                }
            }).start();
        }
    }
}

// 打印：
// Thread-0抢到车位！
// Thread-2抢到车位！
// Thread-1抢到车位！
// Thread-2离开车位！
// Thread-1离开车位！
// Thread-0离开车位！
// Thread-3抢到车位！
// Thread-5抢到车位！
// Thread-4抢到车位！
// Thread-5离开车位！
// Thread-4离开车位！
// Thread-3离开车位！

原理：

  • semaphore.acquire();获得，假设已经满了则等待，等待其他线程释放。
  • semaphore.release();释放，会将当前的信号量释放+1，然后唤醒等待的线程。

九、读写锁

  • ReadWriteLock接口有一个实现类ReentrantReadWriteLock类。
  • 读可以被多个线程同时读，写的时候只能有一个线程去写。
/**
 * 独占锁（写锁）：一次只能被一个线程占有
 * 共享锁（读锁）：多个线程可以同时占有
 * ReentrantLock:
 * 读-读：可以共存
 * 读-写：不可以共存
 * 写-写：不可以共存
 */
public class ReentrantLockDemo {
    public static void main(String[] args) {
        MyCacheLock myCache = new MyCacheLock();
        // 5个线程写
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.put(temp + "", temp + "");
            }, String.valueOf(i)).start();
        }
        // 5个线程读
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.get(temp + "");
            }, String.valueOf(i)).start();
        }
    }
}
class MyCacheLock {
    private volatile Map<String, Object> map = new HashMap<>();
    // 读写锁，更加细粒度的控制
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    // 写，同时只有一个线程写
    public void put(String key, Object obj) {
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "写入");
            map.put(key, obj);
            System.out.println(Thread.currentThread().getName() + "写入OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }
    // 读，所有线程都可以读
    public void get(String key) {
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "读取");
            map.get(key);
            System.out.println(Thread.currentThread().getName() + "读取OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

后记

Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~

小新要变强
关注
  • 6
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
JavaSE之面对程序语言
07-21
JavaSE，全称Java Standard Edition，是Java编程语言的一个核心组件，主要面向桌面应用程序的开发。面向程序设计，也就是面向对象编程（Object-Oriented Programming, OOP），是Java的重要特性，它允许开发者将复杂...
JAVASE-基础 - 网络编程
最新发布
07-30
介绍了网络编程的概念，网络编程的代码实现
一篇完整学习JUC并发编程（包含实例源码）
MS_SONG的博客
07-12 787
JUC并发编程学习案例+笔记
JUC并发编程（多线程进阶整理）
weixin_47701015的博客
06-12 1503
JUC并发编程 JUC就是java.utilconcurrent 包的工具类
【java 高并发编程之JUC】2w字带你JUC从入门到精通
热门推荐
LoveSummer
02-16 5万+
wait()是让获得对象锁的线程实现等待，会自动释放当前线程占有的对象锁。每个对象（Object）都拥有对象锁，既然要释放当前线程占有的对象锁并让其进入 WAITING 状态，自然是要操作对应的对象（Object）而非当前的线程（Thread为什么sleep()方法定义在Thread中？因为sleep()是让当前线程暂停执行，不涉及到对象类，也不需要获得对象锁。java JUC 中 Object里wait()、notify() 实现原理及实战讲解。
JavaSE高级：JUC并发(下)
雙馬程序猿
11-17 163
JavaSE高级：JUC并发(下)：12.四大函数式接口(必需掌握)、13.Stream流式计算、14.ForkJoin、15.异步回调、16.JMM、17.Volatile、18.玩转单例模式、19.深入理解CAS、20.原子引用、21.各种锁的理解
【开悟篇】Java多线程之JUC从入门到精通
博学谷狂野架构师的博客
06-01 434
1. 多线程 J.U.C 1.1 线程池 1.1.1 线程回顾 1）回顾线程创建方式 继承Thread 实现Runnable 2）线程的状态 NEW：刚刚创建，没做任何操作 Thread thread = new Thread(); System.out.println(thread.getState()); RUNNABLE：调用run，可以执行，但不代表一定在执行（RUNNING,READY） thread.start(); System.out.println(thread.getState
JavaSE多线程编程专题.pptx
06-08
JavaSE多线程编程专题
JavaSE_7_网络编程
02-09
网络编程，TPC程序，ECHO程序，UDP程序
JavaSE之入门必备
07-21
这这文件里的内容适合Java初学者，这也是小编在刚开学学习JavaSE时记录的一些笔记，里面的内容非常适合JavaSE入门者学习，都是浅显易懂的话语，没有太多的官方话，绝对是你初学JavaSE的宝典，针对人群：刚入门的...
Java并发编程JUC实践
wat1r的博客
04-16 120
王者荣耀开始游戏等待 10个玩家，10个线程，模拟加载等待的过程 import java.util.Arrays; import java.util.Random; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * @author: Frank Cooper * @date: 202
J.U.C框架学习顺序
chen7253886的博客
10-09 2574
背景        Java concurrent包提供了很多高性能的并发类，类的设计思路及源码值得我们学习参考，但在学习其原理过程中，作者经常碰到这种情况，在学习ConcurrentHashMap时，里面的部分方法操作牵扯到其他类，例如Unsafe、ReentrantLock，又需要了解ReentrantLock，进而又去学习AQS原理，导致整个学习过程非常的复杂，没有条理性，所以本文主要介绍根据
JUC学习之路(概念、TimeUnit及ThreadFactory) （一）
m0_57806252的博客
01-14 206
什么是JUC Java的并发变成(J.U.C) ，本质上来讲就属于多线程的一种更加设计结构合理的开发框架，例如：Java类集是对数据结构的一种开发框架、JavaIO是对操作系统底层支持的一种开发框架，所以JDK本身也是会提供有开发框架支持的。 J.U.C 是由java.util.concurrent包名称给出的三个首字母缩写，J.U.C的提供是为了方便解决并发编程开发过程之中的性能以及稳定性的设计问题，例如：在传统的多线程开发中，一定可以想到如下的几个机制： ...
JavaSE之JUC基础
weixin_46036165的博客
05-31 191
Juc并发编程 1、什么是JUC JUC：Java原生的并发包，和一些常用的工具类！ 2、线程基础知识回顾 什么是进程和线程？ 进程：QQ.exe 线程：打字、自动保存… 一个进程可以包含多个线程，一个进程至少有一个线程！ Java程序至少有两个线程： GC、Main 并发、并行 并发：多个线程操作同一个资源，交替执行的过程！ 并行：多个线程同时执行！只有在多核CPU下才能完成！ 所以我们使用多线程或者并发编程的目的：提高效率，让CPU一直工作，达到最高处理性能！ 线程有几种状态 线程有 6
JDK中多线程之JUC集合的JDK源码解读配合大神的一起看，秒懂。
MRA__S__的专栏
03-02 2150
一、    “JUC集合”01之框架 1)  概要 之前，在"Java 集合系列目录(Category)"中，讲解了Java集合包中的各个类。接下来，将展开对JUC包中的集合进行学习。在学习之前，先温习一下"Java集合包"。本章内容包括： Java集合包 JUC中的集合类 2)  Java集合包 在“Java 集合系列01之 总体框架”中，介绍java集合的架构。主体内容包括Coll...
JUC学习指南
每个人都是独一无二的，把握好自己的节奏，跟着自己的心走。
04-07 896
文章目录前言学习指南 前言 主要推荐一些视频、博客、专栏来学习juc。本人也是初学小白一枚，之后会深入学习juc知识点的。 博主文章汇总：博客目录索引(持续更新) 学习指南 学习时间：2021.3.26-2021.4.7 这段时间学习了下JUC，说下学习过程吧。入门JUC，建议先要有一些多线程的基础。 ①可以先去掌握一些基础知识点可以看《实战Java高并发程序设计》第一章节。 ②有了基础之后，建议可以先看狂神的视频入门(也就是下面第一个视频)，看的过程中你需要去实操去看一些源码，结合查阅博客大致去了解更
JUC实战必备-全是精华
weixin_43206491的博客
11-22 789
????JUC 简介 JAVA 在 1.5版本中引入了 java.util.concurrent工具包，JUC 就是它的简称，用于处理线程的工具包。 ????重温进程与线程 进程：指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程——资源分配的最小单位。 线程：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位。 线程的状态 NEW：新建 RUNNABLE：准备就绪 BLOCKED：阻塞 WAITING：等待（不见不散） TIMED_WAITIN
JUC学习
qq_45598422的博客
10-08 200
1、什么是JUC java.util工具包 2、线程和进程 进程（Process） 程序是指令和数据的有序集合，本身没有运行的含义，是一个静态的概念。 进程是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位。 线程（Thread） 通常在一个进程中可以包括若干个线程，一个进程中至少有一个线程，不然没有存在的意义，线程是CPU调度和执行的单位 真正的多线程是指有多个CPU，即多核 线程就是独立的执行路径 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致 java开不了线程，只能调用
Java并发工具合集JUC大爆发！！！
BASK2312的博客
04-17 262
如果不足够小，就必须分割成两个子任务，每个子任务在调用invokeAll方法时，又会进入compute方法，看看当前子任务是否需要继续分割成孙任务，如果不需要继续分割，则执行当前子任务并返回结果。优先执行线程 ,用于在线程到达屏障时，优先执行barrierAction，方便处理更复杂的业务场景,一般用于数据的整理以及汇总，例如excel插入一样，等所有线程都插入完了，到达了屏障后，barrierAction线程开始进行保存操作，完成后，接下来由其他线程开始进行插入，然后到达屏障接着就是保存，不断循环。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小新要变强

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值