Java——JUC初识

最新推荐文章于 2024-09-09 16:05:07 发布

嗯哼唉、

最新推荐文章于 2024-09-09 16:05:07 发布

阅读量252

点赞数

分类专栏： Java 文章标签： JUC 并发 Java

本文链接：https://blog.csdn.net/weixin_44240370/article/details/103359032

版权

Java 专栏收录该内容

42 篇文章 1 订阅

订阅专栏

文章目录

本文涉及到的代码已经上传到 https://github.com/xtxxtxxtx/JUC_JVM

1、简介

在Java中，线程部分是一个重点，本文JUC也是关于线程的，JUC是(java.util.concurrent)工具包的简称，这是一个处理线程的工具包，JDK1.5之后出现的，接下来简要介绍一下。

首先先来理解几个概念：

线程：轻量级的进程
进程：后台在运行的程序
并发：多个线程同一时间抢同一份资源
并行：同一时间做很多事情

2、线程

线程是很重要的概念，线程有六种状态：

NEW：尚未启动的线程的线程状态
RUNNABLE：可运行线程的线程状态
BLOCKED：等待监视器锁定时被阻止的线程的线程状态
WAITING：处于等待状态的线程正在等待另一个线程执行特定动作
TIMED_WAITING：具有特定等待时间的等待线程的线程状态
TERMINATED：终止线程的线程状态

线程代码示例：

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

public class SaleTicketDemo01 {

    public static void main(String[] args) {

        Ticket ticket = new Ticket();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i < 40; i++) {
                    ticket.sale();
                }
            }
        }, "A").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i < 40; i++) {
                    ticket.sale();
                }
            }
        }, "B").start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i < 40; i++) {
                    ticket.sale();
                }
            }
        }, "C").start();
    }
}

//资源类 = 实例变量 + 实例方法
class Ticket{
    private int number = 30;

    Lock lock = new ReentrantLock();

    public void sale(){
        lock.lock();
        try {
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "\t卖出第：" + (number--) + "\t还剩下：" + number);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

通过观察上面的代码不难看出，代码冗余量很大，创建每个线程都要实现new Thread()方法这也就导致整体代码非常冗余同时显得有点low，所以下面来介绍一下一种简单的方法——Lambda表达式。

3、Lambda表达式

1、Lambda表达式解决匿名内部类代码冗余
2、函数式接口才能使用Lambda表达式
3、编写Lambda表达式的口诀：拷贝小括号、写死右箭头、落地大括号
4、JDK8接口中可以有实现方法 default(可以有多个default实现方法)
static(可以有多个static静态方法)

来看一个代码案例：

/**
 *   1    拷贝小括号， 写死右箭头， 落地大括号
 *   2    @FunctionalInterface
 *   3    default
 *   4    static
 */
public class LambdaDemo {
    public static void main(String[] args) {

//        Ljy ljy = new Ljy() {
//            @Override
//            public void sayHello() {
//                System.out.println("Hello xuejie!");
//            }
//
//            @Override
//            public int add(int x, int y) {
//                return 0;
//            }
//        };
//        ljy.sayHello();

//        Ljy ljy = () -> {
//            System.out.println("Hello xuejie!");
//        };
//        ljy.sayHello();

        Ljy ljy = (int x, int y) ->{
            System.out.println("Come in the method");
            return x + y;
        };

        System.out.println(ljy.add(1, 2));

        System.out.println(ljy.mul(1, 2));

        System.out.println(Ljy.div(1, 2));

    }
}

@FunctionalInterface
interface Ljy{

//    void sayHello();

    int add(int x, int y);

    default int mul(int x, int y){
        return x * y;
    }

    static int div(int x, int y){
        return x / y;
    }
}

总体来说，Lambda表达式使用非常简单便捷，使得我们的代码变得轻巧了很多。

4、锁分段机制

首先我们要对List、Set、Map有简单的了解：

ArrayList：默认new出来的初始值是为10的Object数组，扩容为原容的一半，通过Arrays.copyOf通过数组进行复制扩容，同时是线程不安全的，线程安全的话可以使用Vector，线程不安全效率第一的话使用ArrayList
HashMap：默认创建出来的初始值是16，扩容时原来值的一倍
同时注意：list、set、map都是线程不安全的。

JDK 1.5之后，在java.util.concurrent包中提供了多种并发容器类来改进同步容器类的性能。其中最主要的就是ConcurrentHashMap。
同样也会介绍CopyOnWriteArrayList，CopyOnWriteArraySet。

ConcurrentHashMap

ConcurrentHashMap就是一个线程安全的hash表。我们知道HashMap是线程不安全的，Hash Table加了锁，是线程安全的，因此它效率低。HashTable加锁就是将整个hash表锁起来，当有多个线程访问时，同一时间只能有一个线程访问，并行变成串行，因此效率低。所以JDK1.5后提供了ConcurrentHashMap，它采用了锁分段机制。
在这里插入图片描述
上图所示ConcurrentHashMap默认分成了16个segment，每个Segment都对应一个Hash表，且都有独立的锁。所以这样就可以每个线程访问一个Segment，就可以并行访问了，从而提高了效率。这就是锁分段。但是，java 8 又更新了，不再采用锁分段机制，也采用CAS算法了。

下面来看一段代码示例：

/**
 * 1、故障现象
 *      java.util.ConcurrentModificationException
 *
 * 2、导致原因
 *
 * 3、解决方法
 *      new Vector<>()
 *      Collections.synchronizedList(new ArrayList<>());
 *      new CopyOnWriteArrayList()
 *
 * 4、优化建议(同样的错误不要出现两次)
 */
public class NotSafeDemo {

    public static void main(String[] args) {

        Map map = new ConcurrentHashMap();

        for (int i = 1; i <= 30; i++) {
            new Thread(() -> {
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 8));
                System.out.println(map);
            }, String.valueOf(i)).start();
        }
    }

    public static void setNotSafe(){
        Set set = new CopyOnWriteArraySet();

        for (int i = 1; i <= 30; i++) {
            new Thread(() -> {
                set.add(UUID.randomUUID().toString().substring(0, 8));
            }, String.valueOf(i)).start();
        }
    }

    public static void listNotSafe(){

        List list = new CopyOnWriteArrayList();

        for (int i = 1; i <= 30 ; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }
}

CopyOnWrite源码：

/**
 * 写时复制
     CopyOnWrite容器即写时复制的容器。往一个容器添加元素的时候，不直接往当前容器Object[]添加，而是先将当前容器Object[]进行Copy，
     复制出一个新的容器Object[] newElements，然后新的容器Object[] newElements里添加元素，添加完元素之后，
     再将原容器的引用指向新的容器 setArray(newElements);这样做的好处是可以对CopyOnWrite容器进行并发的读，
     而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器
 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();
     }
 }
 */