juc并发编程学习笔记上(尚硅谷)

2021/9/13 17:06:32

编程Tag： 编程 new 线程 int lock thread synchronized JUC 硅谷

本文主要是介绍juc并发编程学习笔记上(尚硅谷)，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1、什么是JUC

1.1JUC简介

JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包，JDK 1.5开始出现的。

1.2进程与线程

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。程序是指令、数据及其组织形式的描述，进程是程序的实体。

线程（thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

1.3线程的状态

1.3.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;
    }

1.3.2wait/sleep的区别

（1）sleep是Thread的静态方法，wait是Object的方法，任何对象实例都能调用。
（2）sleep不会释放锁，它也不需要占用锁。wait会释放锁，但调用它的前提是当前线程占有锁(即代码要在synchronized中)。
（3）它们都可以被interrupted方法中断。

1.4并发与并行

并发：同一时刻多个线程在访问同一个资源，多个线程对一个点
例子：春运抢票电商秒杀…
并行：多项工作一起执行，之后再汇总
例子：泡方便面，电水壶烧水，一边撕调料倒入桶中

1.5管程

管程(monitor)是保证了同一时刻只有一个进程在管程内活动,即管程内定义的操作在同一时刻只被一个进程调用(由编译器实现).但是这样并不能保证进程以设计的顺序执行
JVM中同步是基于进入和退出管程(monitor)对象实现的，每个对象都会有一个管程(monitor)对象，管程(monitor)会随着java对象一同创建和销毁
执行线程首先要持有管程对象，然后才能执行方法，当方法完成之后会释放管程，方法在执行时候会持有管程，其他线程无法再获取同一个管程

1.6用户线程和守护线程

用户线程:平时用到的普通线程,自定义线程
守护线程:运行在后台,是一种特殊的线程,比如垃圾回收
当主线程结束后,用户线程还在运行,JVM存活
如果没有用户线程,都是守护线程,JVM结束

2、lock接口

2.1synchronized关键字回顾

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
　　2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
　　3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
　　4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：
1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有；
2）线程执行发生异常，此时JVM会让线程自动释放锁。
那么如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，试想一下，这多么影响程序执行效率。
因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断），通过Lock就可以办到。

2.2什么是lock

Lock与的Synchronized区别
• Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；
• Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

2.2.1lock接口

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}

2.2.2lock()

lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。
采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。通常使用Lock来进行同步的话，是以下面这种形式去使用的：

Lock lock = ...; 
lock.lock(); 
try{ 
	//处理任务 
} catch(Exception ex){ 

} finally{
	lock.unlock(); //释放锁 
}

2.2.3 newCondition

关键字synchronized与wait()/notify()这两个方法一起使用可以实现等待/通知模式， Lock锁的newContition()方法返回Condition对象，Condition类也可以实现等待/通知模式。
用notify()通知时，JVM会随机唤醒某个等待的线程，使用Condition类可以进行选择性通知， Condition比较常用的两个方法：
• await()会使当前线程等待,同时会释放锁,当其他线程调用signal()时,线程会重新获得锁并继续执行。
• signal()用于唤醒一个等待的线程。

注意：在调用Condition的await()/signal()方法前，也需要线程持有相关的Lock锁，调用await()后线程会释放这个锁，在singal()调用后会从当前Condition对象的等待队列中，唤醒一个线程，唤醒的线程尝试获得锁，一旦获得锁成功就继续执行。

2.3 ReentrantLock

ReentrantLock，意思是“可重入锁”，关于可重入锁的概念将在后面讲述。
ReentrantLock是唯一实现了Lock接口的类，并且ReentrantLock提供了更多的方法。

2.4 ReadWriteLock

ReadWriteLock也是一个接口，在它里面只定义了两个方法：

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading
     */
    Lock readLock();

    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing
     */
    Lock writeLock();
}

一个用来获取读锁，一个用来获取写锁。也就是说将文件的读写操作分开，分成2个锁来分配给线程，从而使得多个线程可以同时进行读操作。下面的ReentrantReadWriteLock实现了ReadWriteLock接口。
ReentrantReadWriteLock里面提供了很多丰富的方法，不过最主要的有两个方法：readLock()和writeLock()用来获取读锁和写锁。

注意：

如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。
如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

2.5Lock和synchronized的区别

Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；
通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
Lock可以提高多个线程进行读操作的效率。
在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。

2.6synchronized实现案例

public class Ticket {
    private Integer count = 30;

    public synchronized void sale(){
        if (count > 0){
            System.out.println(Thread.currentThread().getName() + "卖出第" + (count--) + "张票");
        }
    }
}

测试:

	public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        },"AA").start();

        new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        },"BB").start();

        new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        },"CC").start();
    }

2.7lock实现案例

public class LTicket {
    private Integer count = 30;

    private ReentrantLock lock = new ReentrantLock();

    public void sale(){
        lock.lock();
        try {
            if (count > 0){
                System.out.println(Thread.currentThread().getName() + "卖出第" + (count--) + "张票");
            }
        } catch (Exception e){

        } finally {
            lock.unlock();
        }
    }
}

测试:

	public static void main(String[] args) {
        LTicket ticket = new LTicket();
        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        }, "AA").start();

        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        }, "BB").start();

        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        }, "CC").start();
    }

3、线程间通信

线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析:

场景—两个线程，一个线程对当前数值加1，另一个线程对当前数值减1,要求用线程间通信

3.1synchronized方案

资源类:

public class DemoEntity {
    private int number = 0;

    public synchronized void incr() {
        try {
            while (number > 0){
                this.wait();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "::" + number);
            notifyAll();
        } catch (Exception e){
            e.printStackTrace();
        }
    }

    public synchronized void decr() {
        try {
            while (number <= 0){
                this.wait();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "::" + number);
            notifyAll();
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

多线程调用:

public static void main(String[] args) {
        DemoEntity demoEntity = new DemoEntity();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                demoEntity.incr();
            }
        }, "AA").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                demoEntity.decr();
            }
        }, "BB").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                demoEntity.incr();
            }
        }, "CC").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                demoEntity.decr();
            }
        }, "DD").start();
    }

3.2lock方案

资源类:

public class LDemoEntity {
    private int number = 0;

    private Lock lock = new ReentrantLock();

    private Condition condition = lock.newCondition();

    public void incr() {
        lock.lock();
        try {
            while (number > 0){
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "::" + number);
            condition.signalAll();
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void decr() {
        lock.lock();
        try {
            while (number <= 0){
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "::" + number);
            condition.signalAll();
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

多线程调用:

public static void main(String[] args) {
    LDemoEntity demoEntity = new LDemoEntity();
    new Thread(()->{
        for (int i = 0; i < 10; i++) {
            demoEntity.incr();
        }
    }, "AA").start();

    new Thread(()->{
        for (int i = 0; i < 10; i++) {
            demoEntity.decr();
        }
    }, "BB").start();

    new Thread(()->{
        for (int i = 0; i < 10; i++) {
            demoEntity.incr();
        }
    }, "CC").start();

    new Thread(()->{
        for (int i = 0; i < 10; i++) {
            demoEntity.decr();
        }
    }, "DD").start();
}

3.3线程间定制化通信

资源类:

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

/**
 * @author lyz
 * @Title: CustomDemoEntity
 * @Description:
 * @date 2021/9/13 13:14
 */
public class CustomDemoEntity {
    private int flag = 1;

    private Lock lock = new ReentrantLock();

    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

    public void printA(int loop){
        lock.lock();
        try {
            while (flag != 1){
                c1.await();
            }
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + "::第" + loop + "次循环::" + flag);
            }
            flag = 2;
            c2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB(int loop){
        lock.lock();
        try {
            while (flag != 2){
                c2.await();
            }
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "::第" + loop + "次循环::" + flag);
            }
            flag = 3;
            c3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC(int loop){
        lock.lock();
        try {
            while (flag != 3){
                c3.await();
            }
            for (int i = 0; i < 15; i++) {
                System.out.println(Thread.currentThread().getName() + "::第" + loop + "次循环::" + flag);
            }
            flag = 1;
            c1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

多线程调用:

public static void main(String[] args) {
        CustomDemoEntity demoEntity = new CustomDemoEntity();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                demoEntity.printA(i);
            }
        }, "AA").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                demoEntity.printB(i);
            }
        }, "BB").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                demoEntity.printC(i);
            }
        }, "CC").start();
    }

3.4多线程编程步骤

1.创建资源类，在资源类创建属性和操作方法

判断
干活
通知

2.创建多个线程,调用资源类的操作方法

3.防止虚假唤醒问题

4、集合的线程安全

4.1ArrayList线程安全问题

测试代码:

public static void main(String[] args) {
//        List<String> list = new ArrayList<>();
//        List<String> list = new Vector<>();
//        List<String> list = Collections.synchronizedList(new ArrayList<>());
        List<String> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString());
                System.out.println(list);
            }, "aa").start();
        }
    }

ArrayList的add方法并发读写时发生java.util.ConcurrentModificationException异常，它并不是一个线程安全的集合。

使用Vector或Collections.synchronizedList来保证list并发执行时的线程安全(底层使用synchronized)。

4.2CopyOnWriteArrayList

它相当于线程安全的ArrayList。和ArrayList一样，它是个可变数组；但是和ArrayList不同的时，它具有以下特性：

它最适合于具有以下特征的应用程序：List 大小通常保持很小，只读操作远多于可变操作，需要在遍历期间防止线程间的冲突。
它是线程安全的。
因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove() 等等）的开销很大。
迭代器支持hasNext(), next()等不可变操作，但不支持可变 remove()等操作。
使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照。

当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行 Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    private static final long serialVersionUID = 8673264195747942595L;

    /** The lock protecting all mutators */
    final transient ReentrantLock lock = new ReentrantLock();

    /** The array, accessed only via getArray/setArray. */
    private transient volatile Object[] array;

    final Object[] getArray() {
        return array;
    }
    final void setArray(Object[] a) {
        array = a;
    }
    
    /**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     */
    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

4.3HashSet线程安全问题

测试代码:

public static void main(String[] args) {
//        Set<String> list = new HashSet<>();
//        Set<String> list = Collections.synchronizedSet(new HashSet<>());
        Set<String> list = new CopyOnWriteArraySet<>();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0,6));
                System.out.println(list);
            }, "aa").start();
        }
    }

使用Collections.synchronizedSet或CopyOnWriteArraySet解决Set集合线程安全问题。

4.4HashMap线程安全问题

测试代码:

public static void main(String[] args) {
//        Map<String, String> list = new HashMap<>();
//        Map<String, String> list = Collections.synchronizedMap(new HashMap<>());
        Map<String, String> list = new ConcurrentHashMap<>();
        for (int i = 0; i < 20; i++) {
            String key = String.valueOf(i);
            new Thread(() -> {
                list.put(key, UUID.randomUUID().toString().substring(0,6));
                System.out.println(list);
            }, "aa").start();
        }
    }

使用Collections.synchronizedMap或ConcurrentHashMap解决Map集合线程安全问题。

4.5 小结

1.线程安全与线程不安全集合

集合类型中存在线程安全与线程不安全的两种,常见例如:

ArrayList ----- Vector

HashMap -----HashTable

但是以上都是通过synchronized关键字实现,效率较低

2.Collections构建的线程安全集合

3.java.util.concurrent并发包下

CopyOnWriteArrayList、CopyOnWriteArraySet、ConcurrentHashMap(推荐)

这篇关于juc并发编程学习笔记上(尚硅谷)的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

juc并发编程学习笔记上(尚硅谷)

1、什么是JUC

1.1JUC简介

1.2进程与线程

1.3线程的状态

1.3.1线程状态枚举类

1.3.2wait/sleep的区别

1.4并发与并行

1.5管程

1.6用户线程和守护线程

2、lock接口

2.1synchronized关键字回顾

2.2什么是lock

2.2.1lock接口

2.2.2lock()

2.2.3 newCondition

2.3 ReentrantLock

2.4 ReadWriteLock

2.5Lock和synchronized的区别

2.6synchronized实现案例

2.7lock实现案例

3、线程间通信

3.1synchronized方案

3.2lock方案

3.3线程间定制化通信

3.4多线程编程步骤

4、集合的线程安全

4.1ArrayList线程安全问题

4.2CopyOnWriteArrayList

4.3HashSet线程安全问题

4.4HashMap线程安全问题

4.5 小结

相关编程文章