丹辰子DCZ

JUC高并发编程

1.JUC概述

1.1什么是juc

在 Java 中，线程部分是一个重点，本篇文章说的 JUC 也是关于线程的。JUC就是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包，JDK 1.5 开始出现的。

1.2 线程和进程概念

1.进程和线程

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

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

总结来说:
进程：指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程——资源分配的最小单位。
线程：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位。

2.线程的状态

class Thread implements Runnable{   
    public enum State {
            /**
             * Thread state for a thread which has not yet started.
             */
        
            NEW,//1.新建

            /**
             * 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,//2.准备就绪

            /**
             * 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,//3.阻塞

            /**
             * Thread state for a waiting thread.
             * A thread is in the waiting state due to calling one of the
             * following methods:
             * 
             *   {@link Object#wait() Object.wait} with no timeout
             *   {@link #join() Thread.join} with no timeout
             *   {@link LockSupport#park() LockSupport.park}
             * 
             *
             * A thread in the waiting state is waiting for another thread to
             * perform a particular action.
             *
             * For example, a thread that has called Object.wait()
             * on an object is waiting for another thread to call
             * Object.notify() or Object.notifyAll() on
             * that object. A thread that has called Thread.join()
             * is waiting for a specified thread to terminate.
             */
            WAITING,//4.等待，不见不散

            /**
             * 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:
             * 

             *   {@link #sleep Thread.sleep}
             *   {@link Object#wait(long) Object.wait} with timeout
             *   {@link #join(long) Thread.join} with timeout
             *   {@link LockSupport#parkNanos LockSupport.parkNanos}
             *   {@link LockSupport#parkUntil LockSupport.parkUntil}
             * 
             */
            TIMED_WAITING,//5.等待，过时不候

            /**
             * Thread state for a terminated thread.
             * The thread has completed execution.
             */
            TERMINATED;//6.终结
        }
    }

3.wati和sleep

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

4.并发和并行

1.串行模式

串行表示所有任务都一一按先后顺序进行。串行意味着必须先装完一车柴才能运送这车柴，只有运送到了，才能卸下这车柴，并且只有完成了这整个三个步骤，才能进行下一个步骤。
串行是一次只能取得一个任务，并执行这个任务。

2.并行模式

并行意味着可以同时取得多个任务，并同时去执行所取得的这些任务。并行模式相当于将长长的一条队列，划分成了多条短队列，所以并行缩短了任务队列的长度。并行的效率从代码层次上强依赖于多进程/多线程代码，从硬件角度上则依赖于多核 CPU。

3. 并发

并发(concurrent)指的是多个程序可以同时运行的现象，更细化的是多进程可以同时运行或者多指令可以同时运行。但这不是重点，在描述并发的时候也不会去扣这种字眼是否精确，并发的重点在于它是一种现象, 并发描述的是多进程同时运行的现象。但实际上，对于单核心 CPU 来说，同一时刻只能运行一个线程。所以，这里的"同时运行"表示的不是真的同一时刻有多个线程运行的现象，这是并行的概念，而是提供一种功能让用户看来多个程序同时运行起来了，但实际上这些程序中的进程不是一直霸占 CPU 的，而是执行一会停一会。要解决大并发问题，通常是将大任务分解成多个小任务, 由于操作系统对程的调度是随机的，所以切分成多个小任务后，可能会从任一小任务处执行。这可能会出现一些现象：

可能出现一个小任务执行了多次，还没开始下个任务的情况。这时一般会采用
队列或类似的数据结构来存放各个小任务的成果
可能出现还没准备好第一步就执行第二步的可能。这时，一般采用多路复用或
异步的方式，比如只有准备好产生了事件通知才执行某个任务。
可以多进程/多线程的方式并行执行这些小任务。也可以单进程/单线程执行这
些小任务，这时很可能要配合多路复用才能达到较高的效率

4. 小结(重点)

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

5.管程

操作系统中叫监视器，java中叫锁

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

6.用户线程和守护线程

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

代码1：

public static void main(String[] args) {
    Thread aa = new Thread(() -> {
        System.out.println(Thread.currentThread().getName()+"用户线程");
        while(true){

        }
    }, "aa");
    aa.start();
    System.out.println(aa.isDaemon()+"==是否是守护线程");
    System.out.println(Thread.currentThread().getName()+"====over");
}

//输出如下，且服务未停止
false==是否是守护线程
main====over
aa用户线程

代码2：

public static void main(String[] args) {
    Thread aa = new Thread(() -> {
        System.out.println(Thread.currentThread().getName()+"用户线程");
        while(true){}
    }, "aa");
    aa.setDaemon(true);
    aa.start();
    System.out.println(aa.isDaemon()+"==是否是守护线程");
    System.out.println(Thread.currentThread().getName()+"====over");
}

//输出如下，且服务已停止
true==是否是守护线程
main====over
aa用户线程

2.LOCK接口

2.1 复习Synchronized

1.Synchronized作用范围

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

修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；

synchronized(this){
}

修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；o 虽然可以使用 synchronized 来定义方法，但 synchronized 并不属于方法定义的一部分，因此，synchronized 关键字不能被继承。如果在父类中的某个方法使用了synchronized 关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized 关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。
修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
修改一个类，其作用的范围是 synchronized 后面括号括起来的部分，作用主的对象是这个类的所有对象。

2.Synchronized实现卖票例子

3个售票员卖出30张票

//1.定义资源，设置资源的操作方式
class Ticket{
    private int num=30;
    public synchronized void sale(){
        if(num>0){
            System.out.println(Thread.currentThread().getName()+"卖出了"+num--+",剩余:"+num);
        }
    }
}
public class SaleTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        //2.创建多线程操作
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<30;i++){
                    ticket.sale();
                }
            }
        },"AA").start();

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

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

3.多线程编程步骤（上)

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

2.第二创建多线程调用资源类的方法

2.2 什么是Lock接口

Lock 锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。它们允许更灵活的结构，可能具有非常不同的属性，并且可能支持多个关联的条件对象。Lock 提供了比 synchronized 更多的功能。

Lock 与的 Synchronized 区别:

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

2.3 Lock实现可重入锁

ReentrantLock

2.4 创建线程的多种方式

1.继承Thread类
2.实现Runnable接口
3.使用Callable接口
4.使用线程池

2.5 使用Lock实现卖票

class LTicket{
    private Integer num = 30;
    //创建可重入锁
    ReentrantLock reentrantLock = new ReentrantLock();
    public void sale(){
        reentrantLock.lock();
        try{
            if(num>0){
                System.out.println(Thread.currentThread().getName()+"卖出了"+num--+"还剩下"+num);
            }
        }finally {
            reentrantLock.unlock();
        }
    }
}
public class SaleTicket {
    public static void main(String[] args) {
        LTicket lTicket = new LTicket();
        new Thread(()->{
            for (int i=0;i<30;i++){
                lTicket.sale();
            }
        },"AA").start();

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

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

start()方法调用时候线程是否会立刻创建?不一定，start()方法源码如下，start0()中的native java代码无能为力，指令给操作系统，具体由操作系统决定。

class Thread implements Runnable {
	public synchronized void start() {
		/**
		 * * This method is not invoked for the main method thread or "system" *
		 * group threads created/set up by the VM. Any new functionality added *
		 * to this method in the future may have to also be added to the VM. * *
		 * A zero status value corresponds to state "NEW".
		 */
		if (threadStatus != 0)
			throw new IllegalThreadStateException();
		/*
		 * Notify the group that this thread is about to be started * so that it
		 * can be added to the group's list of threads * and the group's
		 * unstarted count can be decremented.
		 */ group.add(this);
		boolean started = false;
		try {
			start0();
			started = true;
		} finally {
			try {
				if (!started) {
					group.threadStartFailed(this);
				}
			} catch (Throwable ignore) {
				/*
				 * do nothing. If start0 threw a Throwable then it will be
				 * passed up the call stack
				 */ }
		}
	}

	private native void start0();
}

Lock 和 synchronized 有以下几点不同：

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

3.线程间通信

3.1多线程编程步骤（中)

第二步：在资源类操作方法：

1.判断

2.干活

3.通知

例：有两个线程

实现对一个初始值是0的变量

一个线程对值：+1

一个线程对值：-1

实现+1，-1，+1，-1的交替完成，这个过程就叫做线程间通信

public class Object {
	public final void wait() throws InterruptedException {
		wait(0);
	}

	public final native void notify();

	public final native void notifyAll();
}

线程间通信-synchronized实现：

class Share{
    //第1步:定义资源，资源的操作方法
    private int num = 0;
    //第2步:判断，干活，通知

    //生产
    public synchronized void incr() throws InterruptedException {
        //2.1 判断
        if(num!=0){
            this.wait();
        }
        //2.2 干活
        num++;
        System.out.println(Thread.currentThread().getName()+"==="+num);
        //2.3 通知
        this.notifyAll();
    }

    //消费
    public synchronized void decr() throws InterruptedException {
        //2.1 判断
        if(num!=1){
            this.wait();
        }
        //2.2 干活
        num--;
        System.out.println(Thread.currentThread().getName()+"==="+num);
        //2.3 通知
        this.notifyAll();
    }

}
public class ThreadDemo {
    public static void main(String[] args) {
        Share share = new Share();

        new Thread(() -> {
            try {
                for(int i=1;i<=10;i++){
                    share.incr();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"生产者").start();

        new Thread(() -> {
            try {
                for(int i=1;i<=10;i++){
                    share.decr();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"消费者").start();
    }
}

3.2 虚假唤醒问题

给上述线程间通信-synchronized实现各自多增加一个生产者和消费者，即会出现小于0或者大于1的情况出现，究其原因在于生产者1生产后，生产者2被唤醒并抢到资源，然后wait(),后生产者1又被唤醒，生产者2又被唤醒，因此从wait()地方醒来，继续执行后续逻辑，即产生超过1的数值，消费者小于0同理。

//生产
public synchronized void incr() throws InterruptedException {
    //2.1 判断
    while(num!=0){
        this.wait();
    }
    //2.2 干活
    num++;
    System.out.println(Thread.currentThread().getName()+"==="+num);
    //2.3 通知
    this.notifyAll();
}

//消费
public synchronized void decr() throws InterruptedException {
    //2.1 判断
    while(num!=1){
        this.wait();
    }
    //2.2 干活
    num--;
    System.out.println(Thread.currentThread().getName()+"==="+num);
    //2.3 通知
    this.notifyAll();
}

将上述判断中的if替换为while，即完成在唤醒后的再次判断。

3.3 多线程编程步骤（下)

第四步：防止虚假唤醒问题

3.4 多线程编程步骤总结：

1.第一步：创建资源类，创建属性和操作方法
2.第二步：在资源类操作方法：
- 1.判断
- 2.干活
- 3.通知
3.第三步：创建多线程调用资源类的方法
4.第二步：防止虚假唤醒问题

线程间通信-lock实现：

//java.util.concurrent.locks包下Lock接口
public interface Lock {
    //获取锁
    void lock();
    //如果当前线程未被中断，则获取锁
    void lockInterruptibly() throws InterruptedException;
    //仅在调用时锁为空闲状态才获取该锁
    boolean tryLock();
    //如果锁在给定的等待时间内空闲，并且当前线程未被中断，则获取锁
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    //释放锁
    void unlock();
    //返回绑定到此Lock实例的新Condition实例
    Condition newCondition();
}

public interface Condition {
    //造成当前线程在接到信号或被中断之前一直处于等待状态
    void await() throws InterruptedException;
    //造成当前线程在接到信号之前一直处于等待状态
    void awaitUninterruptibly();
    //造成当前线程在接到信号、被中断或到达等待时间之前一直处于等待状态
    long awaitNanos(long nanosTimeout) throws InterruptedException;
    //造成当前线程在街道信号、被中断或到达指定等待事件之前一直处于等待状态
    boolean await(long time, TimeUnit unit) throws InterruptedException;
    //造成当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态
    boolean awaitUntil(Date deadline) throws InterruptedException;
    //唤醒一个等待线程
    void signal();
    //唤醒所有等待线程
    void signalAll();
}

//1.定义资源，资源的操作
class Share{
    private int num=0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    //2.资源操作里，判断，干活，通知
    //+1
    public void incr() throws InterruptedException {
        lock.lock();
        try {
            //4.防止虚假唤醒
            while(num!=0){
                condition.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName()+"::"+num);
            condition.signalAll();
        } finally {
            lock.unlock();
        }

    }
    //-1
    public void decr() throws InterruptedException {
        lock.lock();
        try{
             //4.防止虚假唤醒
            while (num!=1){
                condition.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName()+"::"+num);
            condition.signalAll();
        }finally {
            lock.unlock();
        }
    }

}

public class ThreadDemo {
    public static void main(String[] args) {
        Share share = new Share();
		//创建多线程调用资源类的方法
        new Thread(() -> {
            try {
                for(int i=1;i<=10;i++){
                    share.incr();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"生产者1").start();

        new Thread(() -> {
            try {
                for(int i=1;i<=10;i++){
                    share.decr();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"消费者1").start();
        
    }
}

4.线程间定制化通信

/**
关键字synchronized与wait()/notify()这两个方法一起使用可以实现等待/通知模式， Lock锁的newContition()方法返回Condition对象，Condition类也可以实现等待/通知模式。

用notify()通知时，JVM会随机唤醒某个等待的线程， 使用Condition类可以进行选择性通知， Condition比较常用的两个方法：

● await()会使当前线程等待,同时会释放锁,当其他线程调用signal()时,线程会重新获得锁并继续执行。

● signal()用于唤醒一个等待的线程。

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

/**
 * @author ：leeliang
 * @date ：Created in 2021/8/1 2:30
 * @description：定制化线程通信
 * @modified By：
 * @version: 1.0$
 */
//1.定义资源，创建属性操作方法
class ShareResource{
    private int flag =1;//1 AA;2 BB;3 CC;
    Lock lock = new ReentrantLock();
    Condition c1 = lock.newCondition();
    Condition c2 = lock.newCondition();
    Condition c3 = lock.newCondition();
    //2.在属性操作方法内:判断，干活，通知

    //打印5次方法
    public void print5(int loop) throws InterruptedException {
        lock.lock();
        //判断
        try{
            while(flag!=1){
                c1.await();
            }
            //干活
            for(int i=1;i<=5;i++){
                System.out.println(Thread.currentThread().getName()+"::第"+i+"次"+"=="+loop+"轮");
            }
            //通知BB线程
            flag=2;
            c2.signal();
        }finally {
            lock.unlock();
        }
    }

    //打印10次方法
    public void print10(int loop) throws InterruptedException {
        lock.lock();
        //判断
        try{
            while(flag!=2){
                c2.await();
            }
            //干活
            for(int i=1;i<=10;i++){
                System.out.println(Thread.currentThread().getName()+"::第"+i+"次"+"=="+loop+"轮");
            }
            //通知CC线程
            flag=3;
            c3.signal();
        }finally {
            lock.unlock();
        }
    }

    //打印15次方法
    public void print15(int loop) throws InterruptedException {
        lock.lock();
        //判断
        try{
            while(flag!=3){
                c3.await();
            }
            //干活
            for(int i=1;i<=15;i++){
                System.out.println(Thread.currentThread().getName()+"::第"+i+"次"+"=="+loop+"轮");
            }
            //通知AA线程
            flag=1;
            c1.signal();
        }finally {
            lock.unlock();
        }
    }
}

public class CustomerThread {

    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        new Thread(()->{
            for(int i=1;i<=10;i++){
                try {
                    shareResource.print5(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"AA").start();

        new Thread(()->{
            for(int i=1;i<=10;i++){
                try {
                    shareResource.print10(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"BB").start();

        new Thread(()->{
            for(int i=1;i<=10;i++){
                try {
                    shareResource.print15(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"CC").start();
    }
}

5.集合的线程安全

5.1ArrayList集合线程不安全演示

//list集合的add方法是线程不安全的
public interface List<E> extends Collection<E> {
    boolean add(E e);
}


public static void main(String[] args) {
    List list = new ArrayList();
    for(int i=0;i<10;i++){
        new Thread(()->{
            String substring = UUID.randomUUID().toString().substring(0, 8);
            list.add(substring);
            System.out.println(list);
        }).start();
    }
}

//报错：ConcurrentModificationException

解决方案1-Vector

//jdk1.0时方案
public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }
}

解决方案2-Collections

//返回指定列表支持的同步列表,比较久远
List list = Collections.synchronizedList(new ArrayList<>());

解决方案3-CopyOnWriteArrayList

package java.util.concurrent
//写时复制技术
List list = new CopyOnWriteArrayList();

//源码,添加为同步操作
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();
    }
}

5.2 HashSet线程不安全

public static void main(String[] args) {
    //Set set = new HashSet();
    //用CopyOnWriteArraySet替代
    Set set = new CopyOnWriteArraySet();
    for(int i=0;i<30;i++){
        new Thread(()->{
            String substring = UUID.randomUUID().toString().substring(0, 8);
            set.add(substring);
            System.out.println(set);
        }).start();
    }
}

5.3 HashMap线程不安全

public static void main(String[] args) {
    //Map map = new HashMap();
    //用ConcurrentHashMap替代
    Map map = new ConcurrentHashMap();
    for(int i=0;i<30;i++){
        String key = String.valueOf(i);
        new Thread(()->{
            String substring = UUID.randomUUID().toString().substring(0, 8);
            map.put(key,substring);
            System.out.println(map);
        }).start();
    }
}

6. 多线程锁

6.1演示锁的八种情况

class Phone {

    public static synchronized void sendSMS() throws Exception {
        //停留4秒
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }

    public synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail");
    }

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


public class Lock_8 {
    public static void main(String[] args) throws Exception {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();

        Thread.sleep(100);

        new Thread(() -> {
            try {
               // phone.sendEmail();
               // phone.getHello();
                phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

1.标准访问，先打印短信还是邮件

-----sendSMS

-----sendEmail

锁当前对象

2.停4秒在短信方法内，先打印短信还是邮件

-----sendSMS

-----sendEmail

锁当前对象

3.新增普通的hello方法，是先打短信还是hello

-----getHello

-----sendSMS

锁当前对象的同步方法

4.现在有两部手机，先打印短信还是邮件

-----sendEmail

-----sendSMS

两部手机，则为不同锁，sendSms有沉睡一秒

5.两个静态同步方法，1部手机，先打印短信还是邮件

-----sendSMS

-----sendEmail

锁的范围不是当前对象，是字节码对象Class

6.两个静态同步方法，2部手机，先打印短信还是邮件

-----sendSMS

-----sendEmail

锁的范围不是当前对象，是字节码对象Class

7.1个静态同步方法，1个普通同步方法，1部手机，先打印短信还是邮件

-----sendEmail

-----sendSMS

锁的范围为字节码对象Class和this当前类对象

8.1个静态同步方法，1个普通同步方法，2部手机，先打印短信还是邮件

-----sendEmail

-----sendSMS

锁的范围为字节码对象Class和this当前类对象

总结：

synchronized实现同步的基础：JAVA中的每一个对象都可以作为锁，具体表现为以下3种形式：

普通同步方法: 锁是当前实例对象

静态同步方法：锁是当前类的Class对象

同步方法快: 锁是synchronized括号里配置的对象

6.2 公平锁和非公平锁

非公平锁：线程饿死，效率高

公平锁：阳光普照，效率相对低

Lock fairSync = new ReentrantLock(false);
Lock nonfairSync = new ReentrantLock(true);

6.3 可重入锁

synchronized（隐式）和Lock（显式）都是可重入锁

//Synchronized演示可重入锁
public static void main(String[] args) {
    Object o = new Object();
    new Thread(()->{
        System.out.println(Thread.currentThread().getName()+"外层");
        synchronized (o){
            System.out.println(Thread.currentThread().getName()+"中层");
            synchronized (o){
                System.out.println(Thread.currentThread().getName()+"内层");
            }
        }
    },"AA").start();
}

//Lock演示可重入锁
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        new Thread(()->{
            try{
                lock.lock();
                System.out.println(Thread.currentThread().getName()+"外层");
                try{
                    lock.lock();
                    System.out.println(Thread.currentThread().getName()+"内层");
                }finally {
                    //注销此行代码，将影响BB线程一直等待释放锁而不能执行
                    //lock.unlock();
                }
            }finally {
                lock.unlock();
            }
        },"AA").start();

        new Thread(()->{
            try{
                lock.lock();
                System.out.println(Thread.currentThread().getName()+"其他");
            }finally {
                    lock.unlock();
            }
        },"BB").start();
    }

6.4 死锁

1 死锁原因

第一：系统资源不足

第二：进程运行推进顺序不合适

第三：资源分配不当

2 死锁模拟

public static void main(String[] args) {
    Object a = new Object();
    Object b = new Object();

    new Thread(()->{
        synchronized (a){
            System.out.println(Thread.currentThread().getName()+"持有a,等待b");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (b){
                System.out.println(Thread.currentThread().getName()+"拿到b");
            }
        }
    },"AA").start();


    new Thread(()->{
        synchronized (b){
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"持有b,等待a");
            synchronized (a){
                System.out.println(Thread.currentThread().getName()+"拿到a");
            }
        }
    },"BB").start();
    
}

3 验证是否是死锁

1.jps 类似linux ps -ef
2.jstack jvm里自带的堆栈跟踪工具

jps -l结果：

jstack 4264结果：

7.Callable接口

callable与runnable接口比较：

1）是否有返回值
2）是否抛出异常
3）实现方法名称不同，一个是run方法，一个是call方法

Thread的类构造方法只有接收Runnable对象，没有接收Callable对象的。因此找一个类，既和Runnable有关系，又和Callable也有关系

Runnable接口有实现类FutureTask
FutureTask构造可以传递Callable

8.JUC强大的辅助类

8.1 减少计数CountDownLatch

CountDownLatch 类可以设置一个计数器，然后通过 countDown 方法来进行减 1 的操作，使用 await 方法等待计数器不大于 0，然后继续执行 await 方法
之后的语句。
• CountDownLatch 主要有两个方法，当一个或多个线程调用 await 方法时，这些线程会阻塞
• 其它线程调用 countDown 方法会将计数器减 1(调用 countDown 方法的线程不会阻塞)
• 当计数器的值变为 0 时，因 await 方法阻塞的线程会被唤醒，继续执行

//场景: 6 个同学陆续离开教室后值班同学才可以关门。
//普通版本
public static void main(String[] args) {
    for(int i=1;i<=6;i++){
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+" 号走了");
        },String.valueOf(i)).start();
    }
    System.out.println("班长锁门了");
}
/*
输出如下：
1 号走了
3 号走了
班长锁门了
2 号走了
4 号走了
5 号走了
6 号走了
*/

//使用countDownLatch
public static void main(String[] args) throws InterruptedException {
    CountDownLatch countDownLatch = new CountDownLatch(6);
    for(int i=1;i<=6;i++){
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+" 号走了");
            countDownLatch.countDown();
        },String.valueOf(i)).start();
    }
    countDownLatch.await();
    System.out.println("班长锁门了");
}
/*
3 号走了
4 号走了
1 号走了
2 号走了
5 号走了
6 号走了
班长锁门了
*/

8.2 循环栅栏CyclicBarrier

CyclicBarrier 看英文单词可以看出大概就是循环阻塞的意思，在使用中CyclicBarrier 的构造方法第一个参数是目标障碍数，每次执行 CyclicBarrier 一
次障碍数会加一，如果达到了目标障碍数，才会执行 cyclicBarrier.await()之后的语句。可以将 CyclicBarrier 理解为加 1 操作

//场景: 集齐 7 颗龙珠就可以召唤神龙
    private final static int NUMBER=7;
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(NUMBER,()->{
            System.out.println("集齐龙珠，召唤神龙。");
        });
        for(int i=1;i<=7;i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+" 号龙珠已经收集");
                try {
                    cyclicBarrier.await();
                System.out.println(Thread.currentThread().getName()+" 号龙珠已经消失");

                } catch (Exception e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }

/**
输出如下：
2 号龙珠已经收集
3 号龙珠已经收集
4 号龙珠已经收集
1 号龙珠已经收集
5 号龙珠已经收集
6 号龙珠已经收集
7 号龙珠已经收集
集齐龙珠，召唤神龙。
*/

8.3 信号灯Semaphore

Semaphore 的构造方法中传入的第一个参数是最大信号量（可以看成最大线程池），每个信号量初始化为一个最多只能分发一个许可证。使用 acquire 方
法获得许可证，release 方法释放许可。

//场景: 抢车位, 6 部汽车 3 个停车位
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);
        for(int i=1;i<=6;i++){
            new Thread(()->{
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"停车");
                    TimeUnit.SECONDS.sleep(new Random().nextInt(5));
                    semaphore.release();
                    System.out.println(Thread.currentThread().getName()+"开走");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
/*
输出如下：
2停车
3停车
1停车
1开走
5停车
3开走
4停车
2开走
5开走
6停车
4开走
6开走
*/

9.ReentrantReadWriteLock读写锁

9.1 读写锁概述

悲观锁效率很低，不支持并发操作

乐观锁，支持并发并且加入version版本号进行控制

表锁：不会发生死锁

行锁：会发生死锁

读锁：共享锁，会产生死锁，因为读的时候可以修改

写锁：独占锁，会产生死锁，因为写的时候可以写多条

9.2 读写锁案例

//不加锁读写
class MyCache{
    private volatile Map<String,Object> map = new HashMap();

    public void put(String key,Object value){
        try{
            System.out.println(Thread.currentThread().getName()+"号线程正在放数");
            TimeUnit.MICROSECONDS.sleep(300);
           map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"号线程已经放完数");
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public Object get(String key){
        Object resultValue = null;
        try{
            System.out.println(Thread.currentThread().getName()+"号线程取数");
            TimeUnit.MICROSECONDS.sleep(300);
            resultValue = map.get(key);
            System.out.println(Thread.currentThread().getName()+"号线程已经取数="+resultValue);
        }catch (Exception e){
            e.printStackTrace();
        }
        return resultValue;
    }

}

public class ThreadDemo6 {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();

        for(int i=1;i<=3;i++){
            final int num = i;
            new Thread(()->{
                myCache.put(num+"",num+"");
            },String.valueOf(i)).start();
        }

        for(int i=1;i<=3;i++){
            final int num = i;
            new Thread(()->{
                myCache.get(num+"");
            },String.valueOf(i)).start();
        }



    }
}
/*
输出结果如下：
1号线程正在放数
3号线程正在放数
2号线程正在放数

1号线程取数
2号线程取数
3号线程取数

2号线程已经放完数
1号线程已经放完数
3号线程已经取数=null
1号线程已经取数=1
3号线程已经放完数
2号线程已经取数=null

Process finished with exit code 0

*/

//读写锁
class MyCache{
    private volatile Map<String,Object> map = new HashMap();

    //创建读写锁
    ReadWriteLock rwLock = new ReentrantReadWriteLock();
    public void put(String key,Object value){
        //加写锁
        rwLock.writeLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+"号线程正在放数");
            TimeUnit.MICROSECONDS.sleep(300);
           map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"号线程已经放完数");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //释放写锁
            rwLock.writeLock().unlock();
        }
    }

    public Object get(String key){
        Object resultValue = null;
        rwLock.readLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+"号线程取数");
            TimeUnit.MICROSECONDS.sleep(300);
            resultValue = map.get(key);
            System.out.println(Thread.currentThread().getName()+"号线程已经取数="+resultValue);
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            rwLock.readLock().unlock();
        }
        return resultValue;
    }
}

public class ThreadDemo6 {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();

        for(int i=1;i<=3;i++){
            final int num = i;
            new Thread(()->{
                myCache.put(num+"",num+"");
            },String.valueOf(i)).start();
        }

        for(int i=1;i<=3;i++){
            final int num = i;
            new Thread(()->{
                myCache.get(num+"");
            },String.valueOf(i)).start();
        }
    }
}
/*
输出管理：
2号线程正在放数
2号线程已经放完数
3号线程正在放数
3号线程已经放完数
1号线程正在放数
1号线程已经放完数
1号线程取数
2号线程取数
3号线程取数
1号线程已经取数=1
2号线程已经取数=2
3号线程已经取数=3
*/

9.3 AQS概述和应用

9.4 读写锁深入

1.读写锁的演变

2.读写锁的降级：

将写入锁降级为读锁

获取写锁—>获取读锁—>释放写锁—>释放读锁

读锁不能升级为写锁

        ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
        ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
        //获取写锁
        writeLock.lock();
        System.out.println("写锁已获取");
        //获取读锁
        readLock.lock();
        System.out.println("读锁已获取");
        //释放写锁
        writeLock.unlock();
        //释放读锁
        readLock.lock();
/*
输出结果：
写锁已获取
读锁已获取
*/

//读锁无法升级为写锁，（读的时候不能写，写的时候可以读???）
		//获取读锁
        readLock.lock();
        System.out.println("读锁已获取");
        //获取写锁
        writeLock.lock();
        System.out.println("写锁已获取");
/*
读锁已获取
*/

10.BlockingQueue阻塞队列

1.阻塞队列概述

Concurrent 包中，BlockingQueue 很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建
高质量的多线程程序带来极大的便利。本文详细介绍了 BlockingQueue 家庭中的所有成员，包括他们各自的功能以及常见使用场景。阻塞队列，顾名思义，首先它是一个队列, 通过一个共享的队列，可以使得数据由队列的一端输入，从另外一端输出；

当队列是空的，从队列中获取元素的操作将会被阻塞
当队列是满的，从队列中添加元素的操作将会被阻塞
试图从空的队列中获取元素的线程将会被阻塞，直到其他线程往空的队列插入新的元素
试图向已满的队列中添加新元素的线程将会被阻塞，直到其他线程从队列中移除一个或多个元素或者完全清空，使队列变得空闲起来并后续新增

在多线程领域：所谓阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会自动被唤起为什么需要 BlockingQueue
好处是我们不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，因为这一切BlockingQueue 都给你一手包办了在 concurrent 包发布以前，在多线程环境下，我们每个程序员都必须去自己控制这些细节，尤其还要兼顾效率和线程安全，而这会给我们的程序带来不小的复杂度。多线程环境中，通过队列可以很容易实现数据共享，比如经典的“生产者”和“消费者”模型中，通过队列可以很便利地实现两者之间的数据共享。假设我们有若干生产者线程，另外又有若干个消费者线程。如果生产者线程需要把准备好的数据共享给消费者线程，利用队列的方式来传递数据，就可以很方便地解决他们之间的数据共享问题。但如果生产者和消费者在某个时间段内，万一发生数据处理速度不匹配的情况呢？理想情况下，如果生产者产出数据的速度大于消费者消费的速度，并且当生产出来的数据累积到一定程度的时候，那么生产者必须暂停等待一下（阻塞生产者线程），以便等待消费者线程把累积的数据处理完毕，反之亦然。

• 当队列中没有数据的情况下，消费者端的所有线程都会被自动阻塞（挂起），直到有数据放入队列
• 当队列中填满数据的情况下，生产者端的所有线程都会被自动阻塞（挂起），直到队列中有空的位置，线程被自动唤醒

2.阻塞队列的架构

3.阻塞队列分类方法

1.ArrayBlockingQueue 由数组结构组成的有界阻塞队列

2.LinkedBlockingQueue 由链表结构组成的有界（但大小默认值为integer.MAX_VALUE）阻塞队列

3.DelayQueue 使用优先级队列实现的延迟无界阻塞队列

4.PriorityBlockingQueue 支持优先级排序的无界阻塞队列

5.SynchronousQueue 不存储元素的阻塞队列，也即单个元素的队列

6.LinkedTransferQueue 由链表组成的无界阻塞队列

7.LinkedBlockingDeque 由链表组成的双向阻塞队列

4.阻塞队列核心方法

       //核心方法演示
		BlockingQueue<String> queue = new ArrayBlockingQueue<>(3);
        //第一组 add remove
        System.out.println(queue.add("a")); //true
        System.out.println(queue.add("b")); //true
        System.out.println(queue.add("c")); //true
//        System.out.println(queue.add("c"));  java.lang.IllegalStateException: Queue full

        System.out.println(queue.remove()); //a
        System.out.println(queue.remove()); //b
        System.out.println(queue.remove()); //c
//        System.out.println(queue.remove()); java.util.NoSuchElementException
        //第二组 offer poll
        System.out.println(queue.offer("a"));   //true
        System.out.println(queue.offer("b"));   //true
        System.out.println(queue.offer("c"));   //true
        System.out.println(queue.offer("d"));   //false

        System.out.println(queue.poll());   //a
        System.out.println(queue.poll());   //b
        System.out.println(queue.poll());   //c
        System.out.println(queue.poll());   //null

        //第三组 put take
        queue.put("a");
        queue.put("b");
        queue.put("c");
        //queue.put("d"); 线程阻塞

        System.out.println(queue.take());
        System.out.println(queue.take());
        System.out.println(queue.take());
//        System.out.println(queue.take());     //线程阻塞

        System.out.println("=================");
        //第四组 offer poll
        queue.offer("a");
        queue.offer("b");
        queue.offer("c");
//        queue.offer("d",3L,TimeUnit.SECONDS); //线程阻塞3秒后退出

        System.out.println(queue.poll());   //a
        System.out.println(queue.poll());   //b
        System.out.println(queue.poll());   //c
//        System.out.println(queue.poll(3L,TimeUnit.SECONDS));     //null 线程阻塞3秒后退出

11. ThreadPool线程池

11.1 线程池概述

线程池（Thread pool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理
者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。
例子： 10 年前单核 CPU 电脑，假的多线程，像马戏团小丑玩多个球，CPU 需要来回切换。现在是多核电脑，多个线程各自跑在独立的 CPU 上，不用切换
效率高。

线程池的优势： 线程池做的工作只要是控制运行的线程数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，
超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。

它的主要特点为：

降低资源消耗: 通过重复利用已创建的线程降低线程创建和销毁造成的销耗。
提高响应速度: 当任务到达时，任务可以不需要等待线程创建就能立即执行。
提高线程的可管理性: 线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

11.2 线程池架构

Java 中的线程池是通过 Executor 框架实现的，该框架中用到了

Executor

Executors

ExecutorService

ThreadPoolExecutor

这几个类

11.3 线程池使用方式

1.一次N线程：Executors.newFixedThreadPool(int)

**作用：**创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。

特征：

线程池中的线程处于一定的量，可以很好的控制线程的并发量
线程可以重复被使用，在显示关闭之前，都将一直存在
超出一定量的线程被提交时候需在队列中等待

创建方式：

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

例：银行窗口对外提供服务，窗口数不变。

2.一个任务一个任务执行，一池一线程：Executors.newSingleThreadExcutor()

**作用：**创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。（注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，那么如果需要，一个新线程将代替它执行后续的任务）。可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。与其他等效的newFixedThreadPool 不同，可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。

特征：

创建方式：

    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

3.线程池根据需求创建线程，可扩容，遇强则强：Executors.newCachedThreadPool()

**作用：**创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程.
创建方式：

线程池中数量没有固定，可达到最大值（Interger. MAX_VALUE）
线程池中的线程可进行缓存重复利用和回收（回收默认时间为 1 分钟）
当线程池中，没有可用线程，会重新创建一个线程

创建方式：

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

三种线程池案例：

//        ExecutorService threadPool1 = Executors.newFixedThreadPool(3);  一次N线程
//        ExecutorService threadPool2 = Executors.newSingleThreadExecutor(); //一个任务一个任务执行
        ExecutorService threadPool3 = Executors.newCachedThreadPool();	//线程池根据需求创建线程
        try{
            for(int i=1;i<=10;i++){
                threadPool3.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" 办理");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally{
//            threadPool1.shutdown();
//            threadPool2.shutdown();
            threadPool3.shutdown();
        }

11.4 线程池底层原理

//无论哪一种线程池，都是new ThreadPoolExecutor(七个参数); 
return new ThreadPoolExecutor(null,null,null,null,null,null,null);

11.5 线程池的七个参数

int corePoolSize			  			核心/常驻线程数量

int maximumPoolsize			 			最大线程数量

long keepAliveTime		      			线程存活时间

TimeUnit unit				  			线程存活时间单位

BlockingQueue<Runnable> workQueue	    阻塞队列
    
ThreadFactory threadFactory				线程工厂

RejectedExecutionHandler handler 		拒绝策略

11.6 线程池底层工作流程

工作流程：

在创建了线程池后，线程池中的线程数为零
当调用 execute()方法添加一个请求任务时，线程池会做出如下判断：

2.1 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务；
2.2 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列；

2.3 如果这个时候队列满了且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务；

2.4 如果队列满了且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会启动饱和拒绝策略来执行。

当一个线程完成任务时，它会从队列中取下一个任务来执行
当一个线程无事可做超过一定的时间（keepAliveTime）时，线程会判断：
4.1 如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。

4.2 所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。

拒绝策略：

注意事项：

项目中创建多线程时，使用常见的三种线程池创建方式，单一、可变、定长都有一定问题，原因是 FixedThreadPool 和 SingleThreadExecutor 底层都是用
LinkedBlockingQueue 实现的，这个队列最大长度为 Integer.MAX_VALUE，容易导致 OOM。所以实际生产一般自己通过 ThreadPoolExecutor 的 7 个参
数自定义线程池。
创建线程池推荐适用 ThreadPoolExecutor 及其 7 个参数手动创建

corePoolSize 线程池的核心线程数
maximumPoolSize 能容纳的最大线程数
keepAliveTime 空闲线程存活时间
unit 存活的时间单位
workQueue 存放提交但未执行任务的队列
threadFactory 创建线程的工厂类
handler 等待队列满后的拒绝策略

为什么不允许适用不允许 Executors.的方式手动创建线程池,如下图

11.7 自定义线程池

        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                2L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(2),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );
        try{
            for(int i=1;i<=8;i++){
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" 办理");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            threadPool.shutdown();
        }

12.Fork/Join分支合并框架

12.1Fork/Join 框架简介

Fork/Join 它可以将一个大的任务拆分成多个子任务进行并行处理，最后将子任务结果合并成最后的计算结果，并进行输出。Fork/Join 框架要完成两件事情：

**Fork：**把一个复杂任务进行分拆，大事化小
**Join：**把分拆任务的结果进行合并

任务分割：首先 Fork/Join 框架需要把大的任务分割成足够小的子任务，如果子任务比较大的话还要对子任务进行继续分割
执行任务并合并结果：分割的子任务分别放到双端队列里，然后几个启动线程分别从双端队列里获取任务执行。子任务执行完的结果都放在另外一个队列里，启动一个线程从队列里取数据，然后合并这些数据。

在 Java 的 Fork/Join 框架中，使用下面类完成上述操作

**ForkJoinTask: **我们要使用 Fork/Join 框架，首先需要创建一个 ForkJoin 任务。该类提供了在任务中执行 fork 和 join 的机制。通常情况下我们不需要直接集
成 ForkJoinTask 类，只需要继承它的子类，Fork/Join 框架提供了两个子类：
- a. RecursiveAction：用于没有返回结果的任务
- b.RecursiveTask: 用于有返回结果的任务
ForkJoinPool: ForkJoinTask 需要通过 ForkJoinPool 来执行
RecursiveTask: 继承后可以实现递归(自己调自己)调用的任务
Fork/Join 框架的实现原理
ForkJoinPool 由 ForkJoinTask 数组和 ForkJoinWorkerThread 数组组成
ForkJoinTask 数组负责将存放以及将程序提交给 ForkJoinPool
ForkJoinWorkerThread 负责执行这些任务。

12.2 Fork/Join 架构

12.3 fork/join实现原理

1.fork方法实现原理：

当我们调用 ForkJoinTask 的 fork 方法时，程序会把任务放在 ForkJoinWorkerThread 的 pushTask 的 workQueue 中，异步地执行这个任务，然后立即返回结果。

    public final ForkJoinTask<V> fork() {
        Thread t;
        if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread)
            ((ForkJoinWorkerThread)t).workQueue.push(this);
        else
            ForkJoinPool.common.externalPush(this);
        return this;
    }

pushTask 方法把当前任务存放在 ForkJoinTask 数组队列里。然后再调用ForkJoinPool 的 signalWork()方法唤醒或创建一个工作线程来执行任务。代码如下：

        final void push(ForkJoinTask<?> task) {
            ForkJoinTask<?>[] a; ForkJoinPool p;
            int b = base, s = top, n;
            if ((a = array) != null) {    // ignore if queue removed
                int m = a.length - 1;     // fenced write for task visibility
                U.putOrderedObject(a, ((m & s) << ASHIFT) + ABASE, task);
                U.putOrderedInt(this, QTOP, s + 1);
                if ((n = s - b) <= 1) {
                    if ((p = pool) != null)
                        p.signalWork(p.workQueues, this);
                }
                else if (n >= m)
                    growArray();
            }
        }

2.join方法实现原理

Join 方法的主要作用是阻塞当前线程并等待获取结果。让我们一起看看ForkJoinTask 的 join 方法的实现，代码如下：

    public final V join() {
        int s;
        if ((s = doJoin() & DONE_MASK) != NORMAL)
            reportException(s);
        return getRawResult();
    }

它首先调用 doJoin 方法，通过 doJoin()方法得到当前任务的状态来判断返回什么结果，任务状态有 4 种：
已完成（NORMAL）

被取消（CANCELLED）

信号（SIGNAL）

异常（EXCEPTIONAL）

如果任务状态是已完成，则直接返回任务结果。
如果任务状态是被取消，则直接抛出 CancellationException
如果任务状态是抛出异常，则直接抛出对应的异常

让我们分析一下dojoin方法：

    private int doJoin() {
        int s; Thread t; ForkJoinWorkerThread wt; ForkJoinPool.WorkQueue w;
        return (s = status) < 0 ? s :
            ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread) ?
            (w = (wt = (ForkJoinWorkerThread)t).workQueue).
            tryUnpush(this) && (s = doExec()) < 0 ? s :
            wt.pool.awaitJoin(w, this, 0L) :
            externalAwaitDone();
    }


    final int doExec() {
        int s; boolean completed;
        if ((s = status) >= 0) {
            try {
                completed = exec();
            } catch (Throwable rex) {
                return setExceptionalCompletion(rex);
            }
            if (completed)
                s = setCompletion(NORMAL);
        }
        return s;
    }

在 doJoin()方法流程如下:

1.首先通过查看任务的状态，看任务是否已经执行完成，如果执行完成，则直接返回任务状态；
2.如果没有执行完，则从任务数组里取出任务并执行。
3.如果任务顺利执行完成，则设置任务状态为 NORMAL，如果出现异常，则记录异常，并将任务状态设置为 EXCEPTIONAL。

3.Fork/Join 框架的异常处理

ForkJoinTask 在执行的时候可能会抛出异常，但是我们没办法在主线程里直接捕获异常，所以 ForkJoinTask 提供了 isCompletedAbnormally()方法来检查
任务是否已经抛出异常或已经被取消了，并且可以通过 ForkJoinTask 的getException 方法获取异常。getException 方法返回 Throwable 对象，如果任务被取消了则返回CancellationException。如果任务没有完成或者没有抛出异常则返回 null。

12.4入门案例

场景: 生成一个计算任务，计算 1+2+3…+100,每 10 个数切分一个子任务


/**
 * 分支合并案例
 */
class MyTask extends RecursiveTask<Integer> {
    //拆分差值不能超过10
    private static final Integer 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() {
        //判断两个数的差值是否大于10
        if(end-begin<=VALUE){
            //累加
            for(int i=begin;i<=end;i++){
                result+=i;
            }
        }else{
            //进一步拆分
            int middle = (begin+end)/2;
            //拆分左边
            MyTask leftTask = new MyTask(begin, middle);
            //拆分右边
            MyTask rightTask = new MyTask(middle+1, end);
            //调用拆分方法
            leftTask.fork();
            rightTask.fork();
            //合并结果
           result = leftTask.join() + rightTask.join();
        }
        return result;
    }
}

public class TaskExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.创建MyTask对象
        MyTask myTask = new MyTask(1, 100);
        //2.创建分支合并池对象
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Integer> submit = forkJoinPool.submit(myTask);
        //3.获取最终得到的结果
        Integer result = submit.get();
        System.out.println(result);
    }
}

13. CompletableFuture异步回调

13.1CompletableFuture 简介

CompletableFuture 在 Java 里面被用于异步编程，异步通常意味着非阻塞，可以使得我们的任务单独运行在与主线程分离的其他线程中，并且通过回调可以在主线程中得到异步任务的执行状态，是否完成，和是否异常等信息。

CompletableFuture 实现了 Future, CompletionStage 接口，实现了 Future接口就可以兼容现在有线程池框架，而 CompletionStage 接口才是异步编程的接口抽象，里面定义多种异步方法，通过这两者集合，从而打造出了强大的CompletableFuture 类。

13.2 Future 与 CompletableFuture

Futrue 在 Java 里面，通常用来表示一个异步任务的引用，比如我们将任务提交到线程池里面，然后我们会得到一个 Futrue，在 Future 里面有 isDone 方法来判断任务是否处理结束，还有 get 方法可以一直阻塞直到任务结束然后获取结果，但整体来说这种方式，还是同步的，因为需要客户端不断阻塞等待或者不断轮询才能知道任务是否完成。

Future 的主要缺点如下：
（1）不支持手动完成
我提交了一个任务，但是执行太慢了，我通过其他路径已经获取到了任务结果，现在没法把这个任务结果通知到正在执行的线程，所以必须主动取消或者一直等待它执行完成
（2）不支持进一步的非阻塞调用通过 Future 的 get 方法会一直阻塞到任务完成，但是想在获取任务之后执行额外的任务，因为 Future 不支持回调函数，所以无法实现这个功能
（3）不支持链式调用对于 Future 的执行结果，我们想继续传到下一个 Future 处理使用，从而形成一个链式的 pipline 调用，这在 Future 中是没法实现的。
（4）不支持多个 Future 合并比如我们有 10 个 Future 并行执行，我们想在所有的 Future 运行完毕之后，执行某些函数，是没法通过 Future 实现的。
（5）不支持异常处理Future 的 API 没有任何的异常处理的 api，所以在异步运行时，如果出了问题是不好定位的。

13.3 CompletableFuture 入门

1)使用 CompletableFuture

**场景:**主线程里面创建一个 CompletableFuture，然后主线程调用 get 方法会阻塞，最后我们在一个子线程中使其终止。

  /**
     * 主线程里面创建一个 CompletableFuture，然后主线程调用 get 方法会阻塞，最后我们
     在一个子线程中使其终止
     * @param args
     */
    public static void main(String[] args) throws Exception{
        CompletableFuture<String> future = new CompletableFuture<>();
        new Thread(() -> {
            try{
                System.out.println(Thread.currentThread().getName() + "子线程开始干活");
                //子线程睡 5 秒
                Thread.sleep(5000);
                //在子线程中完成主线程
                future.complete("success");
            }catch (Exception e){
                e.printStackTrace();
            }
        }, "A").start();
        //主线程调用 get 方法阻塞
        System.out.println("主线程调用 get 方法获取结果为: " + future.get());
        System.out.println("主线程完成,阻塞结束!!!!!!");
    }

2)没有返回值的异步任务

    /**
     * 没有返回值的异步任务
     * @param args
     */
    public static void main(String[] args) throws Exception{
        System.out.println("主线程开始");
        //运行一个没有返回值的异步任务
        CompletableFuture<Void> future = CompletableFuture.runAsync(()-> {
            try {
                System.out.println("子线程启动干活");
                Thread.sleep(5000);
                System.out.println("子线程完成");
            } catch (Exception e) {
                e.printStackTrace();
            }
         });
        //主线程阻塞
        future.get();
        System.out.println("主线程结束");
    }

3)有返回值的异步任务

   /**
     * 没有返回值的异步任务
     * @param args
     */
    public static void main(String[] args) throws Exception{
        System.out.println("主线程开始");
        //运行一个有返回值的异步任务
        CompletableFuture<String> future =
                CompletableFuture.supplyAsync(() -> {
                    try {
                        System.out.println("子线程开始任务");
                        Thread.sleep(5000);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    return "子线程完成了!";
                });
        //主线程阻塞
        String s = future.get();
        System.out.println("主线程结束, 子线程的结果为:" + s);
    }

4)线程依赖

当一个线程依赖另一个线程时，可以使用 thenApply 方法来把这两个线程串行化。

   private static Integer num = 10;
    /**
     * 先对一个数加 10,然后取平方
     * @param args
     */
    public static void main(String[] args) throws Exception{
        System.out.println("主线程开始");
        CompletableFuture<Integer> future =
                CompletableFuture.supplyAsync(() -> {
                    try {
                        System.out.println("加 10 任务开始");
                        num += 10;
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    return num;
                }).thenApply(integer -> {
                    return num * num;
                });
        Integer integer = future.get();
        System.out.println("主线程结束, 子线程的结果为:" + integer);
    }

5)消费处理结果

thenAccept 消费处理结果, 接收任务的处理结果，并消费处理，无返回结果。

 public static void main(String[] args) throws Exception{
        System.out.println("主线程开始");
        CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println("加 10 任务开始");
                num += 10;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return num;
        }).thenApply(integer -> {
            return num * num;
        }).thenAccept(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println("子线程全部处理完成,最后调用了 accept,结果为:" +
                        integer);
            }
        });
    }

6)异常处理

exceptionally 异常处理,出现异常时触发

public static void main(String[] args) throws Exception{
    System.out.println("主线程开始");
    CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
        int i= 1/0;
        System.out.println("加 10 任务开始");
        num += 10;
        return num;
    }).exceptionally(ex -> {
        System.out.println(ex.getMessage());
        return -1;
    });
    System.out.println(future.get());
}

handle 类似于 thenAccept/thenRun 方法,是最后一步的处理调用,但是同时可以处理异常

    public static void main(String[] args) throws Exception{
        System.out.println("主线程开始");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("加 10 任务开始");
            num += 10;
            return num;
        }).handle((i,ex) ->{
            System.out.println("进入 handle 方法");
            if(ex != null){
                System.out.println("发生了异常,内容为:" + ex.getMessage());
                return -1;
            }else{
                System.out.println("正常完成,内容为: " + i);
                return i;
            }});
        System.out.println(future.get());
    }

7)结果合并

thenCompose 合并两个有依赖关系的 CompletableFutures 的执行结果

public static void main(String[] args) throws Exception{
    System.out.println("主线程开始");
    //第一步加 10
    CompletableFuture<Integer> future = CompletableFuture.supplyAsync(()->{
        System.out.println("加 10 任务开始");
        num += 10;
        return num;
    });
    //合并
    CompletableFuture<Integer> future1 = future.thenCompose(i->
    //再来一个 CompletableFuture
            CompletableFuture.supplyAsync(() -> {
                return i + 1;
            }));
    System.out.println(future.get());
    System.out.println(future1.get());
}

thenCombine 合并两个没有依赖关系的 CompletableFutures 任务

public static void main(String[] args) throws Exception{
    System.out.println("主线程开始");
    CompletableFuture<Integer> job1 = CompletableFuture.supplyAsync(() -> {
        System.out.println("加 10 任务开始");
        num += 10;
        return num;
    });
    CompletableFuture<Integer> job2 = CompletableFuture.supplyAsync(() -> {System.out.println("乘以 10 任务开始");
        num = num * 10;
        return num;
    });
    //合并两个结果
    CompletableFuture<Object> future = job1.thenCombine(job2, new
            BiFunction<Integer, Integer, List<Integer>>() {
                @Override
                public List<Integer> apply(Integer a, Integer b) {
                    List<Integer> list = new ArrayList<>();
                    list.add(a);
                    list.add(b);
                    return list;
                }
            });
    System.out.println("合并结果为:" + future.get());
}

合并多个任务的结果 allOf 与 anyOf
allOf: 一系列独立的 future 任务，等其所有的任务执行完后做一些事情

/**
 * 先对一个数加 10,然后取平方
 * @param args
 */
public static void main(String[] args) throws Exception{
    System.out.println("主线程开始");
    List<CompletableFuture> list = new ArrayList<>();
    CompletableFuture<Integer> job1 = CompletableFuture.supplyAsync(() -> {
        System.out.println("加 10 任务开始");
        num += 10;
        return num;
    });
    list.add(job1);
    CompletableFuture<Integer> job2 = CompletableFuture.supplyAsync(() -> {
        System.out.println("乘以 10 任务开始");num = num * 10;
        return num;
    });
    list.add(job2);
    CompletableFuture<Integer> job3 = CompletableFuture.supplyAsync(() -> {
        System.out.println("减以 10 任务开始");
        num = num * 10;
        return num;
    });
    list.add(job3);
    CompletableFuture<Integer> job4 = CompletableFuture.supplyAsync(() -> {
        System.out.println("除以 10 任务开始");
        num = num * 10;
        return num;
    });
    list.add(job4);
    //多任务合并
    List<Integer> collect =
            list.stream().map(CompletableFuture<Integer>::join).collect(Collectors.toList());
    System.out.println(collect);
}

anyOf: 只要在多个 future 里面有一个返回，整个任务就可以结束，而不需要等到每一个future 结束

/**
 * 先对一个数加 10,然后取平方
 * @param args
 */
public static void main(String[] args) throws Exception{
    System.out.println("主线程开始");
    CompletableFuture<Integer>[] futures = new CompletableFuture[4];
    CompletableFuture<Integer> job1 = CompletableFuture.supplyAsync(() -> {
        try{
            Thread.sleep(5000);
            System.out.println("加 10 任务开始");num += 10;
            return num;
        }catch (Exception e){
            return 0;
        }
    });
    futures[0] = job1;
    CompletableFuture<Integer> job2 = CompletableFuture.supplyAsync(() -> {
        try{
            Thread.sleep(2000);
            System.out.println("乘以 10 任务开始");
            num = num * 10;
            return num;
        }catch (Exception e){
            return 1;
        }
    });
    futures[1] = job2;
    CompletableFuture<Integer> job3 = CompletableFuture.supplyAsync(() -> {
        try{
            Thread.sleep(3000);
            System.out.println("减以 10 任务开始");
            num = num * 10;
            return num;
        }catch (Exception e){
            return 2;
        }
    });
    futures[2] = job3;
    CompletableFuture<Integer> job4 = CompletableFuture.supplyAsync(() -> {
        try{
            Thread.sleep(4000);
            System.out.println("除以 10 任务开始");num = num * 10;
            return num;
        }catch (Exception e){
            return 3;
        }
    });
    futures[3] = job4;
    CompletableFuture<Object> future = CompletableFuture.anyOf(futures);
    System.out.println(future.get());
}

你可能感兴趣的:(多线程,JUC,高并发,高并发编程,多线程)

nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
多线程之——ExecutorCompletionService 阿福德
在我们开发中，经常会遇到这种情况，我们起多个线程来执行，等所有的线程都执行完成后，我们需要得到个线程的执行结果来进行聚合处理。我在内部代码评审时，发现了不少这种情况。看很多同学都使用正确，但比较啰嗦，效率也不高。本文介绍一个简单处理这种情况的方法：直接上代码：publicclassExecutorCompletionServiceTest{@TestpublicvoidtestExecutorCo
python多线程程序设计之一 IT_Beijing_BIT #Python 程序设计语言 python
python多线程程序设计之一全局解释器锁线程APIsthreading.active_count()threading.current_thread()threading.excepthook(args,/)threading.get_native_id()threading.main_thread()threading.stack_size([size])线程对象成员函数构造器start/ru
MongoDB知识概括 GeorgeLin98 持久层 mongodb
MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
Python多线程实现大规模数据集高效转移 sand&wich 网络 python 服务器
背景在处理大规模数据集时，通常需要在不同存储设备、不同服务器或文件夹之间高效地传输数据。如果采用单线程传输方式，当数据量非常大时，整个过程会非常耗时。因此，通过多线程并行处理可以大幅提升数据传输效率。本文将分享一个基于Python多线程实现的高效数据传输工具，通过遍历源文件夹中的所有文件，将它们移动到目标文件夹。工具和库这个数据集转移工具主要依赖于以下Python标准库：os：用于文件系统操作，如
Python实现下载当前年份的谷歌影像 sand&wich python 开发语言
在GIS项目和地图应用中，获取最新的地理影像数据是非常重要的。本文将介绍如何使用Python代码从Google地图自动下载当前年份的影像数据，并将其保存为高分辨率的TIFF格式文件。这个过程涉及地理坐标转换、多线程下载和图像处理。关键功能该脚本的核心功能包括：坐标转换：支持WGS-84与WebMercator投影之间转换，以及处理中国GCJ-02偏移。自动化下载：多线程下载地图瓦片，提高效率。图像
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
华为云分布式缓存服务DCS 8月新特性发布华为云PaaS服务小智华为云分布式缓存
分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
Redis:缓存击穿我的程序快快跑啊缓存 redis java
缓存击穿(热点key)：部分key(被高并发访问且缓存重建业务复杂的)失效,无数请求会直接到数据库，造成巨大压力1.互斥锁：可以保证强一致性线程一：未命中之后，获取互斥锁，再查询数据库重建缓存，写入缓存，释放锁线程二：查询未命中，未获得锁(已由线程一获得)，等待一会，缓存命中互斥锁实现方式：redis中setnxkeyvalue:改变对应key的value,仅当value不存在时执行，以此来实现互
mybatis 二级缓存失效_Mybatis 缓存原理及失效情况解析 weixin_39844942 mybatis 二级缓存失效
这篇文章主要介绍了Mybatis缓存原理及失效情况解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下1、什么是缓存[Cache]存在内存中的临时数据。将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。2、为什么要使用缓存减少和数据库的交互次
[转载] NoSQL简介 weixin_30325793 大数据数据库运维
摘自“百度百科”。NoSQL，泛指非关系型的数据库。随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。虽然NoSQL流行语
高并发内存池（4）——实现CentralCache Niu_brave 高并发内存池项目笔记 c++学习
目录一，CentralCache的简单介绍二，CentralCache的整体结构三，CentralCache实现的详细代码1，成员2，函数1，获取单例对象的指针2，FetchRangeObj函数3，GetOneSpan函数实现4，ReleaseListToSpans函数实现一，CentralCache的简单介绍CentralCache是高并发内存池这个项目的中间层。当第一层ThreadCache内
C# 开发教程-入门基础天马3798 教程系列整理 c#开发语言
1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
[面试高频问题]关于多线程的单例模式朱玥玥要每天学习 java 单例模式开发语言
单例模式什么是设计模式?设计模式可以看做为框架或者是围棋中的”棋谱”,红方当头炮,黑方马来跳.根据一些固定的套路下,能保证局势不会吃亏.在日常的程序设计中,往往有许多业务场景,根据这些场景,大佬们总结出了一些固定的套路.按照这个套路来实现代码,也不会吃亏.什么是单例模式,保证某类在程序中只有一个实例,而不会创建多份实例.单例模式具体的实现方式:可分为”懒汉模式”,”饿汉模式”.饿汉模式类加载的同时
SpringBoot整合ES搜索引擎实现网站热搜词及热度计算码踏云端 springboot Elasticsearch spring boot elasticsearch 后端热搜词热度计算 java
博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
基于flask做大模型SSE输出 Mark_Aussie nlp flask python 后端
默认情况下，Fask以多线程模式运行，每个请求都落在一个新线程上。SSE：基于HTTP的协议，用于实现服务器向客户端推送实时数据。使用长轮询机制，客户端通过HTTP连接向服务器发送请求，并保持该连接打开，服务器可以随时向客户端推送新的数据。SSE协议使用简单的文本格式，数据通过纯文本的消息流进行传输，每个消息以"data:"开头，以两个换行符"\n\n"结尾，如果传递的数据中有字典要使用变量传递。
【仿RabbitMQ消息队列项目day2】使用muduo库中基于protobuf的应用层协议进行通信月夜星辉雪 rabbitmq 网络分布式 c++后端服务器 linux
一.什么是muduo?muduo库是⼀个基于非阻塞IO和事件驱动的C++高并发TCP网络编程库。简单来理解，它就是对原生的TCP套接字的封装，是一个比socket编程接口更好用的编程库。二.使用muduo库完成一个英译汉翻译服务TranslateServer.hpp:#pragmaonce#include#include#include#include#include"muduo/net/TcpC
为什么Node.js不适合CPU密集型应用？ weixin_54503231 node.js
Node.js不适合CPU密集型应用的原因主要基于其设计理念和核心特性，具体可以归纳为以下几点：单线程模型Node.js采用单线程模型来处理用户请求和异步I/O操作。虽然这种模型在处理高并发I/O密集型任务时非常高效，因为它避免了传统多线程模型中的线程上下文切换开销，但这也意味着它不能充分利用现代多核CPU的计算能力。对于需要大量计算资源的CPU密集型应用，单线程模型会成为瓶颈，导致应用性能受限。
使用 RabbitMQ 实现秒杀订单系统的异步消息处理 c137范特西 rabbitmq 分布式
使用RabbitMQ实现秒杀订单系统的异步消息处理在秒杀系统中，如何确保高并发环境下的订单处理稳定高效是个很大的挑战。为了解决这个问题，我们通常会引入消息队列，通过异步处理来削峰填谷。这篇文章将详细讲解如何使用RabbitMQ来设计一个秒杀订单系统的异步消息处理流程，重点是如何使用交换机（Exchange）、队列（Queue）、路由键（RoutingKey）以及死信队列（DeadLetterQue
Spring Boot 请求处理流程：从负载均衡到多实例并发 - 电子商务网站实例烟雨国度 spring boot 负载均衡后端
SpringBoot请求处理流程：从负载均衡到多实例并发-电子商务网站实例SpringBoot请求处理流程：从负载均衡到多实例并发SpringBoot作为一个强大的Java应用开发框架，能够有效地处理高并发请求。本文将基于三个关键流程图，详细分析SpringBoot应用如何从负载均衡到请求处理，再到多实例并发处理的整个过程。1.负载均衡和多实例处理首先，让我们看一下描述负载均衡和多实例处理的流程图
PCL 点云视窗类CloudViewer LeonDL168 PCL 算法计算机视觉人工智能视觉检测图像处理
点云视窗类CloudViewer是简单显示点云的可视化工具类，可以让用户用尽可能少的代码查看点云。注意：点云视窗类不能应用于多线程应用程序中。简单点云可视化如果用户想用几行代码可视化程序中所对应的地物，可以使用下面的代码：#include//...voidfoo(){pcl::PointCloud::Ptrcloud;//...为cloud添加对应的场景pcl::visualization::Cl
互联网 Java 工程师面试题（Java 面试题四）苹果酱0567 面试题汇总与解析 java 中间件开发语言 spring boot 后端
下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
《Android进阶之光》— Android 书籍王睿丶 Android 永无止境《Android进阶之光》Android书籍 Android phoenix 移动开发
文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
《android进阶之光》——多线程编程（上） TAING要一直努力读书笔记
今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
Java应用的数据库连接池连接池性能测试微赚淘客机器人开发者联盟@聚娃科技 java 数据库开发语言
Java应用的数据库连接池连接池性能测试大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！数据库连接池的性能测试是确保Java应用能够高效运行的关键步骤。性能测试可以帮助我们评估连接池在高并发条件下的表现，以及识别可能的性能瓶颈。本文将介绍如何对Java应用中的数据库连接池进行性能测试。性能测试的重要性性能测试对于数据库连接池至关重要，因为它可以：评估性能：确定连接
Nginx Hard模式西木风落中间组件 Nginx Nginx配置详解 Nginx配置优化 Nginx面试hard
一、Nginx简介1.Nginx概述Nginx是一个免费、开源、高性能、轻量级的HTTP和反向代理服务器，也是一个电子邮件（IMAP/POP3）代理服务器。其特点是能支持高并发请求处理，并且占用较少的内存资源，提供稳定的、丰富的模块库，有很高的配置灵活性。目前，几乎所有的web项目，都配有Nginx。Nginx由内核和一系列模块组成，内核提供Web服务的基本功能，启用网路协议、提供运行环境、创建连
Unity3D多线程UI之ScrollYExtand 胡强_79a4
先附上git地址https://github.com/huqiang0204/huqiang.UnitySubThreadUI示例代码请看ScrollExTestPage可以绑定三种模型，头部，尾部，和中间数据部分这里只用到了中间数据模型和头部模型Listdatas=newList();ScrollYExtand.DataTemplatetmp=newScrollYExtand.DataTempl
多线程相关面试题（2024大厂高频面试题系列）小橘子831 后端面试 java 面试后端
1、聊一下并行和并发有什么区别？并发是同一时间应对多件事情的能力，多个线程轮流使用一个或多个CPU并行是同一时间动手做多件事情的能力，4核CPU同时执行4个线程2、说一下线程和进程的区别？进程是正在运行程序的实例，进程中包含了线程，每个线程执行不同的任务不同的进程使用不同的内存空间，在当前进程下的所有线程可以共享内存空间3、如果在java中创建线程有哪些方式？在java中一共有四种常见的创建方式，
Java多线程相关面试题整理长河落日袁同学不积跬步无以至千里 java 笔记多线程锁面试
目录1.什么是线程和进程？线程与进程有什么区别？那什么是上下文切换？进程间怎么通信？什么是用户线程和守护线程？2.并行和并发的区别？3.创建线程的几种方式？Runnable接口和Callable接口的区别？run()方法和start()有什么区别？4.Java线程状态和方法？描述线程的生命周期？一个线程两次调用start()方法会出现什么情况？sleep()和wait()方法的区别是什么？5.并发
python 多线程抓取xunlei磁力下载链接 weixin_53748624 python pycharm
importurllib.requestimportreimporttimeimportthreadingclassSpider(object):def__init__(self):#定义字典，用于保存影片信息self.films_dict={}self.i=1self.lock1=threading.Lock()defstart(self):#调用下载函数，获取下载连接forpageinrang
Enum 枚举 120153216 enum 枚举
原文地址：http://www.cnblogs.com/Kavlez/p/4268601.html Enumeration 于Java 1.5增加的enum type...enum type是由一组固定的常量组成的类型，比如四个季节、扑克花色。在出现enum type之前，通常用一组int常量表示枚举类型。比如这样： public static final int APPLE_FUJI = 0
Java8简明教程 bijian1013 java jdk1.8
Java 8已于2014年3月18日正式发布了，新版本带来了诸多改进，包括Lambda表达式、Streams、日期时间API等等。本文就带你领略Java 8的全新特性。一.允许在接口中有默认方法实现 Java 8 允许我们使用default关键字，为接口声明添
Oracle表维护快速备份删除数据 cuisuqiang oracle 索引快速备份删除
我知道oracle表分区，不过那是数据库设计阶段的事情，目前是远水解不了近渴。当前的数据库表，要求保留一个月数据，且表存在大量录入更新，不存在程序删除。为了解决频繁查询和更新的瓶颈，我在oracle内根据需要创建了索引。但是随着数据量的增加，一个半月数据就要超千万，此时就算有索引，对高并发的查询和更新来说，让然有所拖累。为了解决这个问题，我一般一个月会进行一次数据库维护，主要工作就是备
java多态内存分析麦田的设计者 java 内存分析多态原理接口和抽象类
“ 时针如果可以回头，熟悉那张脸，重温嬉戏这乐园，墙壁的松脱涂鸦已经褪色才明白存在的价值归于记忆。街角小店尚存在吗？这大时代会不会牵挂，过去现在花开怎么会等待。但有种意外不管痛不痛都有伤害，光阴远远离开，那笑声徘徊与脑海。但这一秒可笑不再可爱，当天心
Xshell实现Windows上传文件到Linux主机被触发 windows
经常有这样的需求，我们在Windows下载的软件包，如何上传到远程Linux主机上？还有如何从Linux主机下载软件包到Windows下；之前我的做法现在看来好笨好繁琐，不过也达到了目的，笨人有本方法嘛；我是怎么操作的： 1、打开一台本地Linux虚拟机，使用mount 挂载Windows的共享文件夹到Linux上，然后拷贝数据到Linux虚拟机里面；（经常第一步都不顺利，无法挂载Windo
类的加载ClassLoader 肆无忌惮_ ClassLoader
类加载器ClassLoader是用来将java的类加载到虚拟机中，类加载器负责读取class字节文件到内存中，并将它转为Class的对象（类对象），通过此实例的 newInstance()方法就可以创建出该类的一个对象。其中重要的方法为findClass(String name)。如何写一个自己的类加载器呢？首先写一个便于测试的类Student
html5写的玫瑰花知了ing html5
<html> <head> <title>I Love You!</title> <meta charset="utf-8" /> </head> <body> <canvas id="c"></canvas>
google的ConcurrentLinkedHashmap源代码解析矮蛋蛋 LRU
原文地址： http://janeky.iteye.com/blog/1534352 简述 ConcurrentLinkedHashMap 是google团队提供的一个容器。它有什么用呢？其实它本身是对 ConcurrentHashMap的封装，可以用来实现一个基于LRU策略的缓存。详细介绍可以参见 http://code.google.com/p/concurrentlinke
webservice获取访问服务的ip地址 alleni123 webservice
1. 首先注入javax.xml.ws.WebServiceContext, @Resource private WebServiceContext context; 2. 在方法中获取交换请求的对象。 javax.xml.ws.handler.MessageContext mc=context.getMessageContext(); com.sun.net.http
菜鸟的java基础提升之道——————>是否值得拥有百合不是茶
1，c++，java是面向对象编程的语言，将万事万物都看成是对象；java做一件事情关注的是人物，java是c++继承过来的，java没有直接更改地址的权限但是可以通过引用来传值操作地址，java也没有c++中繁琐的操作，java以其优越的可移植型，平台的安全型，高效性赢得了广泛的认同，全世界越来越多的人去学习java，我也是其中的一员 java组成：
通过修改Linux服务自动启动指定应用程序 bijian1013 linux
Linux中修改系统服务的命令是chkconfig (check config)，命令的详细解释如下: chkconfig 功能说明：检查，设置系统的各种服务。语　　法：chkconfig [ -- add][ -- del][ -- list][系统服务] 或 chkconfig [ -- level <</SPAN>
spring拦截器的一个简单实例 bijian1013 java spring 拦截器 Interceptor
Purview接口 package aop; public interface Purview { void checkLogin(); } Purview接口的实现类PurviesImpl.java package aop; public class PurviewImpl implements Purview { public void check
[Velocity二]自定义Velocity指令 bit1129 velocity
什么是Velocity指令在Velocity中，#set,#if, #foreach, #elseif, #parse等，以#开头的称之为指令，Velocity内置的这些指令可以用来做赋值，条件判断，循环控制等脚本语言必备的逻辑控制等语句，Velocity的指令是可扩展的，即用户可以根据实际的需要自定义Velocity指令自定义指令(Directive)的一般步骤 &nbs
【Hive十】Programming Hive学习笔记 bit1129 programming
第二章 Getting Started 1.Hive最大的局限性是什么？一是不支持行级别的增删改(insert, delete, update)二是查询性能非常差(基于Hadoop MapReduce）,不适合延迟小的交互式任务三是不支持事务2. Hive MetaStore是干什么的？Hive persists table schemas and other system metadata.
nginx有选择性进行限制 ronin47 nginx 动静　限制
http { limit_conn_zone $binary_remote_addr zone=addr:10m; limit_req_zone $binary_remote_addr zone=one:10m rate=5r/s;... server {... location ~.*\.(gif|png|css|js|icon)$ {
java-4.-在二元树中找出和为某一值的所有路径 . bylijinnan java
/* * 0.use a TwoWayLinkedList to store the path.when the node can't be path,you should/can delete it. * 1.curSum==exceptedSum:if the lastNode is TreeNode,printPath();delete the node otherwise
Netty学习笔记 bylijinnan java netty
本文是阅读以下两篇文章时： http://seeallhearall.blogspot.com/2012/05/netty-tutorial-part-1-introduction-to.html http://seeallhearall.blogspot.com/2012/06/netty-tutorial-part-15-on-channel.html 我的一些笔记 ===
js获取项目路径 cngolon js
//js获取项目根路径，如： http://localhost:8083/uimcardprj function getRootPath(){ //获取当前网址，如： http://localhost:8083/uimcardprj/share/meun.jsp var curWwwPath=window.document.locati
oracle 的性能优化 cuishikuan oracle SQL Server
在网上搜索了一些Oracle性能优化的文章，为了更加深层次的巩固[边写边记]，也为了可以随时查看，所以发表这篇文章。 1.ORACLE采用自下而上的顺序解析WHERE子句，根据这个原理，表之间的连接必须写在其他WHERE条件之前，那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾。（这点本人曾经做过实例验证过，的确如此哦！
Shell变量和数组使用详解 daizj linux shell 变量数组
Shell 变量定义变量时，变量名不加美元符号（$，PHP语言中变量需要），如： your_name="w3cschool.cc" 注意，变量名和等号之间不能有空格，这可能和你熟悉的所有编程语言都不一样。同时，变量名的命名须遵循如下规则：首个字符必须为字母（a-z，A-Z）。中间不能有空格，可以使用下划线（_）。不能使用标点符号。不能使用ba
编程中的一些概念，KISS、DRY、MVC、OOP、REST dcj3sjt126com REST
KISS、DRY、MVC、OOP、REST （1）KISS是指Keep It Simple,Stupid（摘自wikipedia），指设计时要坚持简约原则，避免不必要的复杂化。（2）DRY是指Don't Repeat Yourself（摘自wikipedia），特指在程序设计以及计算中避免重复代码，因为这样会降低灵活性、简洁性，并且可能导致代码之间的矛盾。（3）OOP 即Object-Orie
[Android]设置Activity为全屏显示的两种方法 dcj3sjt126com Activity
1. 方法1：AndroidManifest.xml 里，Activity的 android:theme 指定为" @android:style/Theme.NoTitleBar.Fullscreen" 示例: <application
solrcloud 部署方式比较 eksliang solrCloud
solrcloud 的部署其实有两种方式可选，那么我们在实践开发中应该怎样选择呢？第一种：当启动solr服务器时，内嵌的启动一个Zookeeper服务器，然后将这些内嵌的Zookeeper服务器组成一个集群。第二种：将Zookeeper服务器独立的配置一个集群，然后将solr交给Zookeeper进行管理谈谈第一种：每启动一个solr服务器就内嵌的启动一个Zoo
Java synchronized关键字详解 gqdy365 synchronized
转载自：http://www.cnblogs.com/mengdd/archive/2013/02/16/2913806.html 多线程的同步机制对资源进行加锁，使得在同一个时间，只有一个线程可以进行操作，同步用以解决多个线程同时访问时可能出现的问题。同步机制可以使用synchronized关键字实现。当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。当s
js实现登录时记住用户名 hw1287789687 记住我记住密码 cookie 记住用户名记住账号
在页面中如何获取cookie值呢? 如果是JSP的话,可以通过servlet的对象request 获取cookie,可以参考:http://hw1287789687.iteye.com/blog/2050040 如果要求登录页面是html呢?html页面中如何获取cookie呢? 直接上代码了页面:loginInput.html 代码: <!DOCTYPE html PUB
开发者必备的 Chrome 扩展 justjavac chrome
Firebug：不用多介绍了吧https://chrome.google.com/webstore/detail/bmagokdooijbeehmkpknfglimnifench ChromeSnifferPlus：Chrome 探测器，可以探测正在使用的开源软件或者 js 类库https://chrome.google.com/webstore/detail/chrome-sniffer-pl
算法机试题李亚飞 java 算法机试题
在面试机试时，遇到一个算法题，当时没能写出来，最后是同学帮忙解决的。这道题大致意思是：输入一个数，比如4,。这时会输出： &n
正确配置Linux系统ulimit值字符串 ulimit
在Linux下面部署应用的时候，有时候会遇上Socket/File: Can’t open so many files的问题；这个值也会影响服务器的最大并发数，其实Linux是有文件句柄限制的，而且Linux默认不是很高，一般都是1024，生产服务器用其实很容易就达到这个数量。下面说的是，如何通过正解配置来改正这个系统默认值。因为这个问题是我配置Nginx+php5时遇到了，所以我将这篇归纳进
hibernate调用返回游标的存储过程 Supanccy2013 java DAO oracle Hibernate jdbc
注：原创作品，转载请注明出处。上篇博文介绍的是hibernate调用返回单值的存储过程，本片博文说的是hibernate调用返回游标的存储过程。此此扁博文的存储过程的功能相当于是jdbc调用select 的作用。 1，创建oracle中的包，并在该包中创建的游标类型。 ---创建oracle的程
Spring 4.2新特性-更简单的Application Event wiselyman application
1.1 Application Event Spring 4.1的写法请参考10点睛Spring4.1-Application Event 请对比10点睛Spring4.1-Application Event 使用一个@EventListener取代了实现ApplicationListener接口,使耦合度降低; 1.2 示例包依赖 <p

JUC高并发编程

1.JUC概述

1.1什么是juc

1.2 线程和进程概念

1.进程和线程

2.线程的状态

3.wati和sleep

4.并发和并行

1.串行模式

2.并行模式

3. 并发

4. 小结(重点)

5.管程

6.用户线程和守护线程

2.LOCK接口

2.1 复习Synchronized

1.Synchronized作用范围

2.Synchronized实现卖票例子

3.多线程编程步骤（上)

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

2.第二 创建多线程调用资源类的方法

2.2 什么是Lock接口

2.3 Lock实现可重入锁

2.4 创建线程的多种方式

2.5 使用Lock实现卖票

3.线程间通信

3.1多线程编程步骤（中)

3.2 虚假唤醒问题

3.3 多线程编程步骤（下)

3.4 多线程编程步骤总结：

4.线程间定制化通信

5.集合的线程安全

5.1ArrayList集合线程不安全演示

解决方案1-Vector

解决方案2-Collections

解决方案3-CopyOnWriteArrayList

5.2 HashSet线程不安全

5.3 HashMap线程不安全

6. 多线程锁

6.1演示锁的八种情况

6.2 公平锁和非公平锁

6.3 可重入锁

6.4 死锁

1 死锁原因

2 死锁模拟

3 验证是否是死锁

7.Callable接口

8.JUC强大的辅助类

8.1 减少计数CountDownLatch

8.2 循环栅栏CyclicBarrier

8.3 信号灯Semaphore

9.ReentrantReadWriteLock读写锁

9.1 读写锁概述

9.2 读写锁案例

9.4 读写锁深入

1.读写锁的演变

2.读写锁的降级：

10.BlockingQueue阻塞队列

1.阻塞队列概述

2.阻塞队列的架构

3.阻塞队列分类方法

4.阻塞队列核心方法

11. ThreadPool线程池

11.1 线程池概述

11.2 线程池架构

11.3 线程池使用方式

1.一次N线程：Executors.newFixedThreadPool(int)

2.一个任务一个任务执行，一池一线程：Executors.newSingleThreadExcutor()

3.线程池根据需求创建线程，可扩容，遇强则强：Executors.newCachedThreadPool()

11.4 线程池底层原理

11.5 线程池的七个参数

11.6 线程池底层工作流程

11.7 自定义线程池

12.Fork/Join分支合并框架

12.1Fork/Join 框架简介

12.2 Fork/Join 架构

12.3 fork/join实现原理

1.fork方法实现原理：

2.join方法实现原理

3.Fork/Join 框架的异常处理

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

2.第二创建多线程调用资源类的方法