
  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 */
            }
        }
    }
	//这是一个C++底层，Java是没有权限操作底层硬件的
    private native void start0();

3、并发

多线程操作同一个资源。

CPU 只有一核，模拟出来多条线程，天下武功，唯快不破。那么我们就可以使用CPU快速交替，来模拟多线程。
并发编程的本质：充分利用CPU的资源！

4、并行

CPU多核，多个线程可以同时执行。我们可以使用线程池！

获取cpu的核数


        //获取cpu的核数
        System.out.println(Runtime.getRuntime().availableProcessors());

5、线程的状态

Thread类中有个内部枚举，可以看到六种状态


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

开发编程的本质：充分利用CPU的资源

如果量子计算机实现了，则很多中间件就没用了，java语言也会被替代。


//查看线程状态,恩住ctrl，点State
        Thread.State

6、复习wait\sleep

1、来自不同的类

wait => Object

sleep => Thread

一般情况企业中使用休眠是：

TimeUnit.DAYS.sleep(1); //休眠1天
TimeUnit.SECONDS.sleep(1); //休眠1s

2、关于锁的释放

wait 会释放锁；

sleep睡觉了，不会释放锁；（sleep抱着锁睡觉）

3、使用的范围是不同的

wait 必须在同步代码块中；

sleep 可以在任何地方睡；（sleep可以在任何地方睡觉）

4、是否需要捕获异常

wait必须要捕获异常；

sleep必须要捕获异常；（可能发生超时等待）

三、Lock锁（重点）

1、传统的 synchronized


public class demo2Synchronized {
    public static void main(String[] args) {
        // 错误示范
        new Thread(new MyThread()).start();
 
        // 真正的多线程开发，公司中的开发，降低耦合性
        // 线程就是一个单独的资源类，没有任何附属的操作
        // 1、属性、方法
        Ticket ticket = new Ticket();
        new Thread(() -> {
            for (int i = 0; i < 50; i++) {
                ticket.sale();
            }
        }, "A").start();
 
        new Thread(() -> {
            for (int i = 0; i < 50; i++) {
                ticket.sale();
            }
        }, "B").start();
 
        new Thread(() -> {
            for (int i = 0; i < 50; i++) {
                ticket.sale();
            }
        }, "C").start();
    }
}
 
class MyThread implements Runnable {
 
    @Override
    public void run() {
        // 错误示范
    }
}
 
// 资源类OOP
class Ticket {
    private int number = 50;
 
    public synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出了第" + number-- + "张票");
        }
    }
}

代码执行效果，有了顺序

2、Lock

公平锁： 十分公平，必须先来后到~；

非公平锁： 十分不公平，可以插队；(默认为非公平锁)

3、Synchronized和Lock的区别

1、Synchronized 内置的Java关键字，Lock是一个Java类

2、Synchronized 无法判断获取锁的状态，Lock可以判断

3、Synchronized 会自动释放锁，lock必须要手动加锁和手动释放锁！可能会遇到死锁

4、Synchronized 线程1(获得锁->阻塞)、线程2(等待)；lock就不一定会一直等待下去，lock会有一个trylock去尝试获取锁，不会造成长久的等待。

5、Synchronized 是可重入锁，不可以中断的，非公平的；Lock，可重入的，可以判断锁，可以自己设置公平锁和非公平锁；

4、java中断机制

如果程序需要停止正在运行的线程，如果直接stop线程，则有可能导致程序运行不完整，因此Java提供了中断机制。中断（Interrupt）一个线程意味着在该线程完成任务之前停止其正在进行的一切，有效地终止其当前的操作。线程是死亡、还是等待新的任务或者是继续运行至下一步，就取决于这个程序。虽然初次看来它可能显得简单，但是，你必须进行一些预警以实现期望的结果。

你最好还是牢记以下的几点告诫。

①首先，忘掉Thread.stop方法。虽然它确实停止了一个正在运行的线程，然而，这种方法是不安全也是不受提倡的，这意味着，在未来的JAVA版本中，它将不复存在。
②Java的中断是一种协作机制，也就是说通过中断并不能直接STOP另外一个线程，而需要被中断的线程自己处理中断，即仅给了另一个线程一个中断标识，由线程自行处理。

四、8锁问题

如何判断锁的是谁！锁到底锁的是谁？深刻理解我们的锁

锁会锁住：对象、Class

参考文章：

深入理解JUC的8锁现象_8锁问题_散一世繁华，颠半世琉璃的博客-CSDN博客

五、生产者和消费者问题

面试的：单例模式、排序算法、生产者和消费者、死锁。

1、虚假唤醒

参考文章：https://blog.csdn.net/weixin_45668482/article/details/117373700


/**
 * 线程之间的通信问题，生产者消费者问题
 * 线程交替执行，A B 操作同一个变量
 * num = 0
 */
public class demo4Consumer {
    public static void main(String[] args) {
 
        // if判断是虚假的唤醒，会发生线程抢占现象
        // 应该用while循环
        modify modify = new modify();
 
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    modify.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();
 
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    modify.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();
 
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    modify.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();
 
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    modify.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "D").start();
 
 
    }
}
 
// 资源类OOP
class modify {
    private int number = 0;
 
    public synchronized void increment() throws InterruptedException {
        // 生产
        if (number != 0) {
            // 等待
            this.wait();
        }
        number++;
        // 通知其他线程，我+1完毕了
        this.notifyAll();
        System.out.println(Thread.currentThread().getName() + " -> " + number);
 
    }
 
    public synchronized void decrement() throws InterruptedException {
        // 消费
        if (number == 0) {
            // 等待
            this.wait();
        }
        number--;
        // 通知其他线程，我+1完毕了
        this.notifyAll();
        System.out.println(Thread.currentThread().getName() + " -> " + number);
 
    }
}

解决方式： if改在while即可，防止虚假唤醒

2、Lock版的等待和唤醒

3剑客，await、signal 替换 wait、notify

3、Condition的优势

相比于wait和notify方法只能随机唤醒线程，Condition的优势：精准的通知和唤醒的线程！

通过condition1、condition2 、condition3 的交替使用，完成流程控制A-->B-->C


    private Lock lock=new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

六、集合类不安全

1、List不安全

会导致ConcurrentModificationException并发修改异常！

ArrayList在并发情况下是不安全的!

解决方案：

（1）用Vector代替

Vector是1.0版发布的，ArrayList是1.2版本发布的。

JDK11又把synchronized优化了，然后让CopyOnWrite又用上了synchronized。O(∩_∩)O

（2）使用Collections工具类的synchronized 包装的Set类

和Vector效果一样

（3）**CopyOnWriteArrayList：**写入时复制！ COW 计算机程序设计领域的一种优化策略

多个线程调用的时候，list是唯一的，读取的时候list是固定的，写入的时候给list复制一份给调用者，调用者写入副本，副本再添加到唯一的list中。避免在写入的时候被覆盖，造成数据问题！

核心思想：如果有多个调用者（Callers）同时要求相同的资源（如内存或者是磁盘上的数据存储），他们会共同获取相同的指针指向相同的资源，直到某个调用者视图修改资源内容时，系统才会真正复制一份专用副本（private copy）给该调用者，而其他调用者所见到的最初的资源仍然保持不变。这过程对其他的调用者都是透明的（transparently）。此做法主要的优点是如果调用者没有修改资源，就不会有副本（private copy）被创建，因此多个调用者只是读取操作时可以共享同一份资源。

读的时候不需要加锁，如果读的时候有多个线程正向CopyOnWriteArrayList添加数据，读还是会读到旧数据，因为写的时候不会锁住旧的CopyOnWriteArrayList。

CopyOnWriteArrayList比Vector厉害在哪里？

①Vector底层是使用synchronized 关键字来实现的：效率特别低下。

②CopyOnWriteArrayList 使用的是Lock锁，效率会更加高效！


        // 不安全的例子
//        List<String> list1 = new ArrayList<>();
        // Vector来解决
//        List<String> list1 = new Vector<>();
//        List<String> list1 = Collections.synchronizedList(new ArrayList<>());
        // 使用JUC包中的对象
        List<String> list1 = new CopyOnWriteArrayList<>();

2、Set不安全

Set和List同理可得：多线程情况下，普通的Set集合是线程不安全的；

解决方案有两种：

使用Collections工具类的synchronized 包装的Set类；
使用CopyOnWriteArraySet 写入复制的 JUC解决方案；

HashSet底层是什么？

hashSet底层就是一个HashMap；


        // 不安全的例子
//        Set<String> set = new HashSet<>();
//        Set<String> set = Collections.synchronizedSet(new HashSet<>());
        // 使用JUC包中的对象
        Set<String> set = new CopyOnWriteArraySet<>();

3、Map不安全

解决方案有两种：

使用Collections工具类的synchronized 包装的Map类；
使用CopyOnWriteArrayMap 写入复制的 JUC解决方案；


        // 不安全的例子
//        Map<String, String> map = new HashMap<>();
//        Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
        // 使用JUC包中的对象
        Map<String, String> map = new ConcurrentHashMap<>();

七、Callable（简单）

1、callable和runnable的区别

callable可以有返回值
callable可以抛出异常
callable方法不同，run()/call()

2、使用Callable进行多线程操作

我们通过Thread的源码分析Thread的参数只有Runnable，不能直接启动Callable。

Runnable接口中有一个FutureTask实现类

FutureTask的构造方法中的参数中有Callable和Runnable


 
public class demo7Callable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 我们通常使用Runnable的启动是
//        new Thread(new Runnable()).start();
        // 因为FutureTask是Runnable的实现类，所以上面的启动代码等价于下面的代码
//        new Thread(new FutureTask<V>()).start();
        // Callable是FutureTask的参数，所以启动代码为
//        new Thread(new FutureTask<V>(Callable)).start();
 
        // 步骤解析
        MyThread2 myThread2 = new MyThread2();
        FutureTask<String> stringFutureTask = new FutureTask<>(myThread2);
 
        // 运行两个Thread，只会返回一个结果，结果被缓存了，效率更高
        new Thread(stringFutureTask, "A").start();
        new Thread(stringFutureTask, "B").start();
 
        //返回值
        //这个get方法很有可能会被阻塞，如果在call方法中是一个耗时的方法，就会等待很长时间。
        //所以我们一般情况下回把这一行放到最后，或者使用异步通信
        String s = stringFutureTask.get();
        System.out.println(s);
 
    }
 
}
 
class MyThread2 implements Callable<String> {
 
    @Override
    public String call() {
        System.out.println(Thread.currentThread().getName() + "：调用了Callable");
        return "success";
    }
}

八、常用的辅助类(必会)

1、CountDownLatch

减法计数器

主要方法：

countDown 减1操作；
await 等待计数器归零；

await等待计数器归零，就唤醒，再继续向下运行。


public class CountDownLatchDemo {
	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()+" Go out");
                countDownLatch.countDown(); //每个线程都数量-1
			},String.valueOf(i)).start();
		}
		 countDownLatch.await();//等待计数器归零,就是执行了6次new Thread 后清零,才继续往下执行  
		 System.out.println("close door");
	}
}

2、CyclickBarrier

其实就是一个加法计数器；

当线程数达到设置的7时,才触发await(),唤醒,召唤出神龙


        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, () -> {
            System.out.println("召唤神龙!!!");
        });
        if (!cyclicBarrier.isBroken()) {
            for (int i = 0; i < 5; i++) {
                int s = i;
                new Thread(() -> {
                    System.out.println(Thread.currentThread().getName() + s + "召唤龙珠");
                    try {
                        cyclicBarrier.await();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }, "cyclicBarrier").start();
            }
            System.out.println(Thread.currentThread().getName() + ":执行完毕！");
        }

3、Semaphore

原理：

semaphore.acquire() 获得资源，如果资源已经使用完了，就等待资源释放后再进行使用！
semaphore.release()释放 ，会释放当前的信号量，然后唤醒等待的线程！

作用：

多个资源互斥时使用！并发限流，控制最大的线程数！


 
        Semaphore semaphore = new Semaphore(3, true);
        for (int i = 0; i < 6; i++) {
            int s = i;
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + s + "抢车位");
                    TimeUnit.MILLISECONDS.sleep(100);
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }, "semaphore").start();
        }
        System.out.println(Thread.currentThread().getName() + ":执行完毕！");

九、读写锁

先对于不加锁的情况：

如果我们做一个我们自己的cache缓存。分别有写入操作、读取操作；

我们采用五个线程去写入，使用十个线程去读取。

我们来看一下这个的效果，如果我们不加锁的情况！


 
public class demo9ReadWriteLock {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for (int i = 0; i < 5; i++) {
            String s = String.valueOf(i);
            new Thread(() -> {
                myCache .put(s, s);
            }, "write" + i).start();
        }
 
        for (int i = 0; i < 10; i++) {
            String s = String.valueOf(i);
            new Thread(() -> {
                myCache .get(s);
            }, "read" + i).start();
        }
    }
}
 
class MyReadWriteLock {
    private volatile Map<String, String> map = new HashMap<>();
 
    public void put(String key, String value) {
        System.out.println(Thread.currentThread().getName() + " 线程 开始写入");
        map.put(key, value);
        System.out.println(Thread.currentThread().getName() + " 线程 写入OK");
    }
 
    public void get(String key) {
        System.out.println(Thread.currentThread().getName() + " 线程 开始读取");
        map.get(key);
        System.out.println(Thread.currentThread().getName() + " 线程 读取OK");
    }
}

执行结果：


 
Thread-0 线程 开始写入
Thread-4 线程 开始写入  # 插入了其他的线程进行写入
Thread-4 线程 写入OK
Thread-3 线程 开始写入
Thread-1 线程 开始写入
Thread-2 线程 开始写入
Thread-1 线程 写入OK
Thread-3 线程 写入OK
Thread-0 线程 写入OK   # 对于这种情况会出现 数据不一致等情况
Thread-2 线程 写入OK
Thread-5 线程 开始读取
Thread-6 线程 开始读取

所以如果我们不加锁的情况，多线程的读写会造成数据不可靠的问题。

我们也可以采用synchronized这种重量锁和轻量锁 lock去保证数据的可靠。

但是这次我们采用更细粒度的锁：ReadWriteLock 读写锁来保证


 
/**
 * 独占锁（写锁），一次只能被一个线程占有
 * 共享锁（读锁），多个线程可以同时
 * 写-写 不可以共存
 * 写-读 不可以共存
 * 读-读 可以共存
 */
class MyReadWriteLock {
    private volatile Map<String, String> map = new HashMap<>();
 
    private ReentrantLock lock = new ReentrantLock();
    private ReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
 
    // 写，写入的时候只希望有一个线程存
    public void put(String key, String value) {
        reentrantReadWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 线程 开始写入");
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + " 线程 写入OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            reentrantReadWriteLock.writeLock().unlock();
        }
    }
 
    // 读，同时可以有多个一起读，读的时候不能写
    public void get(String key) {
        reentrantReadWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 线程 开始读取");
            map.get(key);
            TimeUnit.SECONDS.sleep(1);
            System.out.println(Thread.currentThread().getName() + " 线程 读取OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            reentrantReadWriteLock.readLock().unlock();
        }
    }
}

执行结果：


write3 线程 开始写入
write3 线程 写入OK
read0 线程 开始读取
read2 线程 开始读取
read1 线程 开始读取
read4 线程 开始读取
read3 线程 开始读取
read3 线程 读取OK
read0 线程 读取OK
read1 线程 读取OK
read4 线程 读取OK
read2 线程 读取OK

十、阻塞队列

1、BlockingQueue

blockingQueue 是Collection的一个子类

什么情况我们会使用阻塞队列呢？

多线程并发处理、线程池！

BlockingQueue有四组API

方式	抛出异常	不会抛出异常，有返回值	阻塞，等待	超时等待
添加	add()	offer()	put()	offer(timenum.timeUnit)
移出	remove()	poll()	take()	poll(timenum,timeUnit)
检测队首元素	element()	peek()


 
class testQueue {
    /**
     * 抛出异常
     */
    public void test1() {
        System.out.println("抛出异常");
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(2);
        System.out.println(arrayBlockingQueue.add("1"));
        System.out.println(arrayBlockingQueue.add("2"));
        System.out.println(arrayBlockingQueue.add("3"));
        // 如果多添加一个
        // 抛出异常：java.lang.IllegalStateException: Queue full
 
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());
        // 如果多移除一个
        // 这也会造成 java.util.NoSuchElementException 抛出异常
    }
 
    /**
     * 不会抛出异常，有返回值
     */
    public void test2() {
        System.out.println("不会抛出异常，有返回值");
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(2);
        System.out.println(arrayBlockingQueue.offer("1"));
        System.out.println(arrayBlockingQueue.offer("2"));
        System.out.println(arrayBlockingQueue.offer("3"));
        // 如果多添加一个
        // false
 
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        // 如果多移除一个
        // null
    }
 
    /**
     * 阻塞，等待
     */
    public void test3() throws InterruptedException {
        System.out.println("阻塞，等待");
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(2);
        arrayBlockingQueue.put("1");
        arrayBlockingQueue.put("2");
//        arrayBlockingQueue.put("3");
        // 如果多添加一个
        // 阻塞，卡死
 
        System.out.println(arrayBlockingQueue.take());
        System.out.println(arrayBlockingQueue.take());
//        System.out.println(arrayBlockingQueue.take());
        // 如果多移除一个
        // 阻塞，卡死
    }
 
    /**
     * 超时等待
     */
    public void test4() throws InterruptedException {
        System.out.println("超时等待");
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(2);
        arrayBlockingQueue.offer("1", 2, TimeUnit.SECONDS);
        arrayBlockingQueue.offer("2", 2, TimeUnit.SECONDS);
        arrayBlockingQueue.offer("3", 2, TimeUnit.SECONDS);
        // 如果多添加一个
        // 等2秒结束
 
        arrayBlockingQueue.poll(2, TimeUnit.SECONDS);
        arrayBlockingQueue.poll(2, TimeUnit.SECONDS);
        arrayBlockingQueue.poll(2, TimeUnit.SECONDS);
        // 如果多移除一个
        // 等2秒结束
    }
}

2、SynchronousQueue

同步队列

特点：

同步队列没有容量，也可以视为容量为1的队列；
进去一个元素，必须等待取出来之后，才能再往里面放入一个元素；

put方法和 take方法

SynchronousQueue和其他的BlockingQueue 不一样它不存储元素；
put了一个元素，就必须从里面先take出来，否则不能再put进去值！
并且SynchronousQueue 的take是使用了lock锁保证线程安全的。


Thread-0put 01
Thread-0put 02
Thread-1take1
Thread-1take2
Thread-0put 03
Thread-1take3

如果不加sleep（），顺序会出错！

十一、线程池(重点)

程序的运行，本质：占用系统的资源！我们需要去优化资源的使用 ====> 池化技术

例如：线程池、JDBC的连接池、内存池、对象池等等…

资源的创建、销毁十分消耗资源

池化技术：事先准备好一些资源，如果有人要用，就来我这里拿，用完之后还给我，以此来提高效率。

1、线程池的好处

1、降低资源的消耗；

2、提高响应的速度；

3、方便管理；

线程复用、可以控制最大并发、管理线程；

2、三大方法、七大参数、四种策略

三大方法

ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
ExecutorService threadPool2 = Executors.newFixedThreadPool(5); //创建一个固定的线程池的大小
ExecutorService threadPool3 = Executors.newCachedThreadPool(); //可伸缩的

七大参数

创建线程时，不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式。

阿里巴巴的Java操作手册中明确说明：对于Integer.MAX_VALUE初始值较大，所以一般情况我们要使用底层的 ThreadPoolExecutor来创建线程池。

四种策略

（1）new ThreadPoolExecutor.AbortPolicy()： //该拒绝策略为：银行满了，还有人进来，不处理这个人的，并抛出异常

超出最大承载，就会抛出异常：队列容量大小+maxPoolSize

（2）new ThreadPoolExecutor.CallerRunsPolicy()： //该拒绝策略为：哪来的去哪里 main线程进行处理

（3）new ThreadPoolExecutor.DiscardPolicy(): //该拒绝策略为：队列满了,丢掉，不会抛出异常。

（4）new ThreadPoolExecutor.DiscardOldestPolicy()： //该拒绝策略为：队列满了，尝试去和最早的进程竞争，不会抛出异常

3、如何去设置线程池的最大大小？

CPU密集型和IO密集型


        // CPU密集型，获取CPU的核心数
        int poolSize = Runtime.getRuntime().availableProcessors();
        // IO密集型，判断你的系统中十分消耗IO的线程数
//        int poolSize = 5;

十二、四大函数式接口（必需掌握）

函数式接口：只有一个方法的接口

1、Function函数型接口

2、Predicate函数型接口

3、Supplier函数型接口

4、Consumer函数型接口

代码实例：demo12Function


        // 函数型接口
        Function<String, String> function = (str) -> str;
        System.out.println(function.apply("123"));
 
        // 断定型接口
        Predicate<String> predicate = (str) -> str.isEmpty();
        System.out.println(predicate.test("123"));
 
        // 生产型接口
        Supplier<String> supplier = () -> "321";
        System.out.println(supplier.get());
 
        // 消费型接口
        Consumer<String> consumer = (str) -> { };
        consumer.accept("123");

十三、Stream流式计算

大数据：存储 + 计算

集合、Mysql本质都是存储东西的；

计算都应该交给流来操作！


        // 长度在1-10之间，小写的1个数字
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.stream()
                .filter(a -> a > 1)
                .filter(a -> a < 10)
                .map(Integer::longValue)
                .sorted()
                .limit(1)
                .forEach(System.out::println);

缺点：stream效率低下可读性差，某些时候lambda的效率不如for循环

效率和问题难定位，若公司要求必须用这个，估计技术总监肯定信耶稣~

十四、ForkJoin

ForkJoin 在JDK1.7中出现，并行执行任务！提高效率。在大数据量速率会更快！

大数据中： MapReduce 核心思想–>把大任务拆分为小任务！

ForkJoin 特点：工作窃取！

实现原理是：双端队列！从上面和下面都可以去拿到任务进行执行！

如何使用ForkJoin？

1、通过ForkJoinPool来执行

2、计算任务 execute(ForkJoinTask<?> task)

3、计算类要去继承 ForkJoinTask

ForkJoin的计算案例


 
    // for循环的方式
    public void calculate1() {
        long start = System.currentTimeMillis();
        long sum = 0L;
        for (int i = 0; i <= 1000000000; i++) {
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("for循环结果：" + sum);
        System.out.println("for循环耗时：" + (end - start));
    }
 
    private long sum = 0L;
 
    // 使用ForkJoinPool的方式
    public void calculate2() {
        long start = System.currentTimeMillis();
//        AtomicLong sum = new AtomicLong(0L);
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        forkJoinPool.execute(() -> {
            for (long i = 0L; i <= 1000000000L; i++) {
                sum += i;
            }
        });
        while (forkJoinPool.getActiveThreadCount() != 0){
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("ForkJoinPool结果：" + sum);
        System.out.println("ForkJoinPool耗时：" + (end - start));
    }
 
    // ForkJoinTask的方式
    public void calculate3() {
        long start = System.currentTimeMillis();
        forkJoinTask forkJoinTask = new forkJoinTask(0L, 1000000001L);
        Long compute = forkJoinTask.compute();
 
        long end = System.currentTimeMillis();
        System.out.println("ForkJoinTask结果：" + compute);
        System.out.println("ForkJoinTask耗时：" + (end - start));
    }
 
    // Stream并行流的方式
    public void calculate4() {
        long start = System.currentTimeMillis();
        long sum;
        sum = LongStream.rangeClosed(0, 1000000000).parallel().reduce(0, Long::sum);
 
        long end = System.currentTimeMillis();
        System.out.println("Stream并行流结果：" + sum);
        System.out.println("Stream并行流耗时：" + (end - start));
    }
 
}
 
// 递归计算大数据的和
class forkJoinTask extends RecursiveTask<Long> {
 
    private Long start;
    private Long end;
    private Long sum = 0L;
 
    public forkJoinTask(Long start, Long end) {
        this.start = start;
        this.end = end;
    }
 
    @Override
    protected Long compute() {
        if ((end - start) <= 100000) {
            for (Long i = start; i < end; i++) {
                sum += i;
            }
            return sum;
        } else {
            // 拆分任务，把线程压入线程队列
            long middle = (end + start) / 2;
            forkJoinTask forkJoinTask1 = new forkJoinTask(start, middle);
            forkJoinTask1.fork();
            forkJoinTask forkJoinTask2 = new forkJoinTask(middle, end);
            forkJoinTask2.fork();
            return forkJoinTask1.join() + forkJoinTask2.join();
        }
    }
}

缺点：计算10亿数据的累加和比for循环慢


for循环结果：500000000500000000
for循环耗时：450
ForkJoinPool结果：500000000500000000
ForkJoinPool耗时：4115
ForkJoinTask结果：500000000500000000
ForkJoinTask耗时：3140
Stream并行流结果：500000000500000000
Stream并行流耗时：204

reduce方法的优点：

十五、异步回调

Future 设计的初衷：对将来的某个事件结果进行建模！

其实就是前端javaScript --> 发送ajax异步请求给后端

随着语言的不断发展，各种编程语言逐渐趋同

我们平时都使用CompletableFuture

1、没有返回值的异步回调runAsync


        // 无返回值
        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(voidCompletableFuture.get());

2、有返回值的异步回调supplyAsync


        // 有返回值
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
                int i = 1 / 0;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "success";
        });
        System.out.println(completableFuture.get());
 
        // 有成功和失败2种情况的
        System.out.println(completableFuture.whenComplete((t, u) -> {
                    System.out.println("t=" + t);
                    System.out.println("u=" + u);
                }).exceptionally((e) -> {
                    System.out.println(e.getMessage());
                    return "false";
                }).get()
        );

whenComplete: 有两个参数，一个是t 一个是u

T：是代表的 正常返回的结果；

U：是代表的 抛出异常的错误信息；

如果发生了异常，get可以获取到exceptionally返回的值；


Connected to the target VM, address: '127.0.0.1:51244', transport: 'socket'
null
t=null
u=java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
java.lang.ArithmeticException: / by zero
false

十六、JMM

JMM：JAVA内存模型，不存在的东西，是一个概念也是一个约定！

关于JMM的一些同步的约定

1、线程解锁前，必须把共享变量立刻刷回主存；

2、线程加锁前，必须 读取主存中的最新值到工作内存中；

3、加锁和解锁是同一把锁；

线程中分为 工作内存、主内存。

8种操作

Read（读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用；
load（载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中；
Use（使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令；
assign（赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中；
store（存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用；
write（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中；
lock（锁定）：作用于主内存的变量，把一个变量标识为线程独占状态；
unlock（解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定；

JMM对这8种操作给了相应的规定：

不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write；
不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存；
不允许一个线程将没有assign的数据从工作内存同步回主内存;
一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是对变量实施use、store操作之前，必须经过assign和load操作;
一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁;
如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值;
如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量;
对一个变量进行unlock操作之前，必须把此变量同步回主内存

有时会出现一个问题，如线程A和线程B同时使用了主存的一个数据，线程B修改了值，但是线程A不能及时可见。

解决方法↓Volatile↓

十七、Volatile

Volatile 是Java虚拟机提供 轻量级的同步机制

提到Volatile我们就会想到它的三个特点！

保证可见性、不保证原子性、禁止指令重排

1、保证可见性

如何实现可见性

volatile变量修饰的共享变量在进行写操作的时候会多出一行汇编：

0x01a3de1d:movb $0×0，0×1104800（%esi）;0x01a3de24**:lock** addl $0×0,(%esp);

Lock前缀的指令在多核处理器下回引发两件事：

将当前处理器缓存行的数据写回到系统内存。
这个写回内存的操作会使其他CPU里缓存了该内存地址的数据无效。

多处理器总线嗅探：

为了提高处理速度，处理器不直接和内存进行通信，而是先将系统内存的数据读到内部缓存后再进行操作，但操作不知道何时会写回到内存。如果对声明了volatile的变量进行写操作，JVM就会向处理器发送一条lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存。但是在 多处理器下 ，为了保证各个处理器的缓存是一致的，就会实现缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己的缓存是不是过期了，如果处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读取到处理器缓存中。

2、不保证原子性

原子性：不可分割；

线程A在执行任务的时候，不能被打扰，也不能被分割，要么同时成功，要么同时失败。


    public static void add() {
        //++ 不是一个原子性操作
        num++;
    }
 
    public void A() {
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                for (int j = 1; j < 1000; j++) {
                    add();
                }
            }).start();
        }
 
        while (Thread.activeCount() > 2) {
            // 礼让，当线程数小于2的时候就停止，因为有两个默认线程：mian、GC
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + ", num=" + num);
    }

结果：每次执行结果都不一样，一般小于2万。

main, num=19981

如果不加lock和synchronized ，怎么样保证原子性？

使用原子类

为什么JUC单独有一个包叫Atomic，因为它非常实用，高效。比锁快很多倍！

分析汇编指令

这些原子类的底层都是直接和操作系统挂钩，是在内存中修改值的。


    public volatile static AtomicInteger numA = new AtomicInteger();
    
    public static void add() {
        // ++ 不是一个原子性操作
        num++;
        // 原子性操作
        numA.getAndIncrement();
    }

查看getAndIncrement()

Unsafe类是一个很特殊的存在；

里面的方法都是native的，是通过C语言保证原子性的。

3、禁止指令重排

什么是指令重排

我们写程序时，计算机并不是按照我们自己写的那样去执行的。

源代码–>编译器优化–>指令并行也可能会重排–>内存系统也会重排–>执行

处理器在进行指令重排的时候，会考虑数据之间的依赖性！


int x=1; //1
int y=2; //2
x=x+5;   //3
y=x*x;   //4
 
//我们期望的执行顺序是 1_2_3_4  可能执行的顺序会变成2134 1324
//可不可能是 4123？ 不可能的
1234567

多线程的情况下，会出现更多的指令混乱问题。

Volatile可以避免指令重排

Volatile中会加一道内存的屏障，这个内存屏障可以保证在这个屏障中的指令顺序。

内存屏障：CPU指令。

作用：

1、保证特定的操作的执行顺序；

2、可以保证某些变量的内存可见性（利用这些特性，就可以保证volatile实现的可见性）

面试官：那么你知道在哪里用这个内存屏障用得最多呢？↓单例模式↓

十八、彻底玩转单例模式

十九、深入理解CAS

二十、原子引用

二十一、各种锁的理解：公平锁、非公平锁、可重入锁、自旋锁、死锁

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/545659