wang_luwei

1 JUC（高并发）

文章目录

- 1.什么是JUC
- 2.进程和线程
- 3.并发与并行
- 4.线程的状态（六个）
- 5.wait/sleep的区别
- 6.Lock锁与Synchronized（重点）
- - 6.1传统的Synchronized （关键字）
  - 6.2lock锁（lock是一个接口）
  - - 6.2.1 ReentrantLock 可重入锁中的公平锁与非公平锁
    - 6.2.2 与6.1不同的加锁方式的买票案例
  - 6.3Synchronized 和 Lock区别
- 7.生产者与消费者问题（线程通信）
- - 7.1传统版本，用Synchronized实现的
  - - 7.1.1存在的问题(虚假唤醒)，线程不只两个时
  - 7.2juc版（lock锁）的生产者与消费者问题
  - - 7.2.1 Condition有什么用呢？
- 8、八锁现象
- - 8.1 问题1与问题2
  - 8.2 问题3与问题4
  - 8.3 问题5与问题6
  - 8.4问题7与问题8
  - 8.5小结
- 9.线程安全与不安全的集合
- - 9.1List中的不安全 (ArrayList 是不安全的)
  - 9.2 set 中的不安全
  - 9.3 map中的不安全
  - 9.4阻塞队列（BlockingQueue接口）
  - - 9.4.1SynchronousQueue同步队列
- 10.Callable(简单)
- 11.常用的辅助类
- - 11.1 CountDownLatch
  - 11.2 CyclicBarrier
  - 11.3 Semaphore
- 12.读写锁ReadWritelock
- 13.线程池
- - 13.1三大方法
  - 13.2七大参数
  - 13.3四种拒绝策略
  - - 13.3.1 new ThreadPoolExecutor.AbortPolicy()
    - 13.3.2 new ThreadPoolExecutor.CallerRunsPolicy()
    - 13.3.3 new ThreadPoolExecutor.DiscardPolicy()
    - 13.3.4 new ThreadPoolExecutor.DiscardOldestPolicy()：
  - 13.4手动创建线程池
  - 13.5小结和拓展(CPU密集型和IO密集型！)
- 14 .四大函数式接口（必需掌握）
- - 14.1 Function

1.什么是JUC

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

2.进程和线程

进程是正在运行的程序，是系统进行资源分配的基本单位（一个程序：例如QQ.exe，Music.exe）
线程，又称轻量级进程(Light Weight Process)。是进程中的一条执行路径，也是CPU的基本调度单位。一个进程由一个或多个线程组成，彼此间完成不同的工作，同时执行（宏观并行，微观串行），称为多线程。(例如：迅雷是一个进程，当中的多个下载任务即是多个线程。)
进程和线程的区别：
- 进程是操作系统资源分配的基本单位，而线程是CPU的基本调度单位
- 一个程序运行后至少有一个进程。
- 一个进程可以包含多个线程，但是至少需要有一个线程，否则这个进程是没有意义。
- 进程间不能共享数据段地址，但同进程的线程之间可以。
java默认有几个线程？2个线程！ main线程、GC线程
对于Java而言：我们之前使用Thread、Runnable、Callable这三种方式来开启线程的
提问？JAVA真的可以开启线程吗？开不了的！（来看一下 Thread().start()的源码）

    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++，在之前的jvm中提到过，Java是没有权限操作的
    private native void start0();

3.并发与并行

并行：并行是针对多处理器（cpu）而言的。指在同一时刻，有多条指令在多个处理器上同时执行。所以无论从微观还是从宏观来看，二者都是一起执行的。（当一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进程互不抢占CPU资源，可以同时进行）
并发：并发描述的是多个进程同时运行的现象（多个进程抢一个cpu）。但实际上，对于单核心CPU来说，同一时刻只能运行一个进程。在单个cpu中，从宏观的角度讲：多个进程是同时进行的，但是在微观的角度来看：只是cpu快速切换不同的进程，让其执行（CPU把一个时间段划分成几个时间片段（时间区间），然后在这几个时间区间之间来回切换，由于CPU处理的速度非常快，只要时间间隔处理得当，即可让用户感觉是多个应用程序同时在进行）
并发编程的本质：充分利用CPU的资源！

public class Test1 {
     
    public static void main(String[] args) {
     
        //获取cpu的核数
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

4.线程的状态（六个）

看源码

public enum State {
     

    	//新生
        NEW,

    	//运行
        RUNNABLE,

    	//阻塞
        BLOCKED,

    	//等待
        WAITING,

    	//超时等待
        TIMED_WAITING,

    	//终止
        TERMINATED;
}

5.wait/sleep的区别

对于捕获异常看一下源码（都是需要捕获异常的）中断异常

java/lang/Thread.java :
public static native void sleep(long millis) throws InterruptedException;

java/lang/Object.java:
public final void wait() throws InterruptedException {
       
    wait(0);
}

6.Lock锁与Synchronized（重点）

6.1传统的Synchronized （关键字）

一个买票案例

package com.wlw.demo01;
/**
 * 真正的多线程开发
 * 线程就是一个单独的资源类，没有任何的附属操作！ (只有属性和方法)
 */
public class SaleTicketDemo01 {
     
    public static void main(String[] args) {
     
        //多线程操作
        //并发：多线程操作同一个资源类，把资源类丢入线程
        final Ticket ticket = new Ticket();

        //@FunctionalInterface 函数式接口 jdk1.8之后 可用lambda表达式来代替
        new Thread(new Runnable() {
     
            public void run() {
     
                for (int i = 0; i < 40; i++) {
     
                    ticket.sale();
                }
            }
        },"A").start();

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

        new Thread(()->{
     
            for (int i = 0; i < 40; i++) {
     
                ticket.sale();
            }
        },"C").start();
    }
}
//资源类
//属性+方法
//oop
class Ticket{
     
    private int number = 50;
    //synchronized的本质就是将多个线程放进一个队列，并对共享的资源加锁，之后获得锁的线程才能使用这个资源
    public synchronized void sale(){
     
        if(number > 0){
     
            System.out.println(Thread.currentThread().getName()+"卖了第"+(number--)+"张票,"+"还剩"+number);
        }
    }
}

6.2lock锁（lock是一个接口）

6.2.1 ReentrantLock 可重入锁中的公平锁与非公平锁

```
Lock lock = new ReentrantLock();
```
点进去看一下源码

/**
 * Creates an instance of {@code ReentrantLock}.
 * This is equivalent to using {@code ReentrantLock(false)}.
 */
public ReentrantLock() {
       
    sync = new NonfairSync(); //非公平锁
}

/**
 * Creates an instance of {@code ReentrantLock} with the
 * given fairness policy.
 *
 * @param fair {@code true} if this lock should use a fair ordering policy
 */
public ReentrantLock(boolean fair) {
       
    sync = fair ? new FairSync() : new NonfairSync(); //FairSync()为公平锁
}

非公平锁： 十分不公平，可以插队；(默认为非公平锁) （这个可以保证运行时间短的线程先执行完，不用一直等待前面的需要很多时间才能执行完的线程）
公平锁： 十分公平，必须先来后到（严格按照先来后到的顺序执行）；

6.2.2 与6.1不同的加锁方式的买票案例

lock锁三部曲
- 1、 Lock lock=new ReentrantLock(); 创建锁
- 2、 lock.lock() 加锁
- 3、 finally块中解锁：lock.unlock();

package com.wlw.demo01;

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

/**
 * SaleTicketDemo01 用的是synchronized 关键字加锁，SaleTicketDemo02用lock锁
 */
public class SaleTicketDemo02 {
     
    public static void main(String[] args) {
     
        //多线程操作
        //并发：多线程操作同一个资源类，把资源类丢入线程
        Ticket2 ticket = new Ticket2();

        //@FunctionalInterface 函数式接口 jdk1.8之后 可用lambda表达式来代替
        new Thread(()->{
      for (int i = 0; i < 40; i++) ticket.sale();},"A").start();
        new Thread(()->{
      for (int i = 0; i < 40; i++) ticket.sale(); },"B").start();
        new Thread(()->{
      for (int i = 0; i < 40; i++) ticket.sale(); },"C").start();
    }
}

//lock锁 三部曲
//1、    Lock lock=new ReentrantLock();
//2、    lock.lock() 加锁
//3、    finally块中 解锁：lock.unlock();
class Ticket2{
     
    private int number = 50;

    Lock lock = new ReentrantLock(); //创建一个可重入锁

    public void sale(){
     
        lock.lock(); //加锁

        try {
     
            //业务代码
            if(number > 0){
     
                System.out.println(Thread.currentThread().getName()+"卖了第"+(number--)+"张票,"+"还剩"+number);
            }
        } catch (Exception e){
     
            e.printStackTrace();
        }
        finally {
     
            lock.unlock(); //解锁
        }
    }
}

6.3Synchronized 和 Lock区别

1、Synchronized 内置的Java关键字，Lock是一个Java接口（在jvm层面，Lock是个java类）
2、Synchronized 无法判断获取锁的状态，Lock可以判断是否获取到锁；
3、Synchronized 会自动释放锁（a 线程执行完同步代码会释放锁；b 线程执行过程中发生异常会释放锁），lock必须要手动加锁和手动释放锁！（unlock()方法释放锁，否则容易造成线程死锁；）
4、用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去， lock就不一定会一直等待下去，lock会有一个trylock去尝试获取锁，不会造成长久的等待，如果尝试获取不到锁，线程可以不用一直等待就结束了；
5、Synchronized 是可重入锁，不可以中断的，默认就是非公平的；Lock，可重入的，可以判断锁，可以自己设置公平锁和非公平锁（默认是非公平的，如果创建可重入锁时加了true就是获得公平锁）；
6、Synchronized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码；

7.生产者与消费者问题（线程通信）

线程之间的通信问题：生产者与消费者问题

7.1传统版本，用Synchronized实现的

package com.wlw.producerandconsumer;

/**
 * 线程之间的通信问题：生产者与消费者问题
 * 两个线程交替执行，操作同一变量，一开始为0，A B 一个执行+1  另一个执行-1
 */
public class demo01_synchronized {
     
    public static void main(String[] args) {
     
        Data data = new Data();

        new Thread(()->{
     
            for (int i = 0; i < 10; i++) {
     
                try {
     
                    data.increment();
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
     
            for (int i = 0; i < 10; i++) {
     
                try {
     
                    data.decrement();
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}

//资源类
//写一个生产者与消费者问题，只有三步：1.判断等待、2.业务、3.唤醒通知
class Data{
     

    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
     
        //1.判断是否需要等待
        if(number != 0){
     
            this.wait();
        }
        //2.业务
        number++;
        System.out.println(Thread.currentThread().getName()+"==>"+number);
        //3.唤醒通知 ,通知线程我+1完毕了
        this.notifyAll();
    }


    //-1
    public synchronized void decrement() throws InterruptedException {
     
        //1.判断是否需要等待
        if(number == 0){
     
            this.wait();
        }
        //2.业务
        number--;
        System.out.println(Thread.currentThread().getName()+"==>"+number);
        //3.唤醒通知 ,通知线程我-1完毕了
        this.notifyAll();
    }
}

7.1.1存在的问题(虚假唤醒)，线程不只两个时

上面的案例中只有两个线程，不会出现问题，假如有四个线程就会出现问题（虚假唤醒问题）
造成虚假唤醒的根本原因是notify唤醒线程和被唤醒的线程获取锁不是原子操作。在线程被唤醒过程中，如果锁被其他线程抢占执行，等持锁线程执行完后，被唤醒线程获得锁执行，就有可能造成临界资源为0的情况下被过度消费为负数的现象（在生产者消费者模式中）。
whlie循环在wait后再进行一次临界资源的判断，如果临界资源不满足要求继续设置线程为等待状态，避免了以上过度消费的问题出现。
虚假唤醒问题解决：将if 换成 while 判断（if只会判断一次，while会一直判断）

package com.wlw.producerandconsumer;

/**
 * 线程之间的通信问题：生产者与消费者问题
 * 四个线程
 */
public class demo01_synchronized{
     
    public static void main(String[] args) {
     
        Data data = new Data();

        new Thread(()->{
     
            for (int i = 0; i < 10; i++) {
     
                try {
     
                    data.increment();
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
     
            for (int i = 0; i < 10; i++) {
     
                try {
     
                    data.decrement();
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
     
            for (int i = 0; i < 10; i++) {
     
                try {
     
                    data.increment();
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(()->{
     
            for (int i = 0; i < 10; i++) {
     
                try {
     
                    data.decrement();
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

//资源类
//写一个生产者与消费者问题，只有三步：1.判断等待、2.业务、3.唤醒通知
class Data{
     

    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
     
        //1.判断是否需要等待
        while (number != 0){
     
            this.wait();
        }
        //2.业务
        number++;
        System.out.println(Thread.currentThread().getName()+"==>"+number);
        //3.唤醒通知 ,通知线程我+1完毕了
        this.notifyAll();
    }


    //-1
    public synchronized void decrement() throws InterruptedException {
     
        //1.判断是否需要等待
        while (number == 0){
     
            this.wait();
        }
        //2.业务
        number--;
        System.out.println(Thread.currentThread().getName()+"==>"+number);
        //3.唤醒通知 ,通知线程我-1完毕了
        this.notifyAll();
    }
}

7.2juc版（lock锁）的生产者与消费者问题

对比一下Synchronized，它有三个关键点：Synchronized加锁，wait等待，notify（notifyAll）唤醒，而juc版的三个关键点：lock加锁，await等待，signal（signalAll）唤醒（jdk帮助文档中写道：在Lock取代synchronized方法和语句的使用，一个Condition取代对象监视器的使用方法。）

await与，signal（signalAll）的使用要通过Condition，而Contidion是通过lock锁来获取的（方法为：newContidion() 返回一个新的Condition实例绑定到该Lock实例。）
生产者与消费者代码

package com.wlw.producerandconsumer;

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


public class demo02_Lock {
     
    public static void main(String[] args) {
     
        Data2 data = new Data2();

        new Thread(()->{
     
            for (int i = 0; i < 10; i++) {
     
                data.increment();
            }
        },"A").start();

        new Thread(()->{
     
            for (int i = 0; i < 10; i++) {
     
                data.decrement();
            }
        },"B").start();

        new Thread(()->{
     
            for (int i = 0; i < 10; i++) {
     
                data.increment();
            }
        },"C").start();

        new Thread(()->{
     
            for (int i = 0; i < 10; i++) {
     
                data.decrement();
            }
        },"D").start();
    }
}

//资源类
//写一个生产者与消费者问题，只有三步：1.判断等待、2.业务、3.唤醒通知
class Data2{
     

    private int number = 0;

    Lock lock = new ReentrantLock(); //创建锁
    Condition condition = lock.newCondition();//返回一个新的Condition实例绑定到该Lock实例。

    //+1
    public void increment(){
     
        lock.lock();//加锁

        try {
     
            //1.判断是否需要等待
            while (number != 0){
     
                condition.await();
            }
            //2.业务
            number++;
            System.out.println(Thread.currentThread().getName()+"==>"+number);
            //3.唤醒通知 ,通知线程我+1完毕了
            condition.signalAll(); //全部唤醒
        } catch (Exception e) {
     
            e.printStackTrace();
        } finally {
     
            lock.unlock(); //解锁
        }
    }


    //-1
    public void decrement() {
     
        lock.lock();

        try {
     
            //1.判断是否需要等待
            while (number == 0){
     
                condition.await();
            }
            //2.业务
            number--;
            System.out.println(Thread.currentThread().getName()+"==>"+number);
            //3.唤醒通知 ,通知线程我-1完毕了
           condition.signalAll();
        } catch (Exception e) {
     
            e.printStackTrace();
        } finally {
     
            lock.unlock();
        }
    }
}

7.2.1 Condition有什么用呢？

任何一个新的技术，绝对不仅仅只是覆盖了原来的技术，它一定有着自己的优势与补充
Condition的优势：精准的通知和唤醒的线程！

package com.wlw.producerandconsumer;

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

/**
 * Condition 实现精准的通知和唤醒的线程！
 * A执行完调用B B行完调用C  C执行完调用A
 */
public class demo03_Condition {
     
    public static void main(String[] args) {
     
        Data3 data3 = new Data3();

        new Thread(()->{
     
            for (int i = 0; i < 10; i++) {
     
                data3.printA();
            }
        },"A").start();
        new Thread(()->{
     
            for (int i = 0; i < 10; i++) {
     
                data3.printB();
            }
        },"B").start();
        new Thread(()->{
     
            for (int i = 0; i < 10; i++) {
     
                data3.printC();
            }
        },"C").start();

    }
}

class Data3{
     

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

    private int number = 1; //number = 1时执行A，2B  3C

    public void printA(){
     
        lock.lock();
        try {
     
            // 判断等待，业务，唤醒
            while(number != 1){
     
                condition1.await(); //等待
            }
            System.out.println(Thread.currentThread().getName()+"==>AAAAAAAAAAAA"); //业务
            number = 2;
            // 唤醒指定的人（线程）B
            condition2.signal();//唤醒
        }catch (Exception e){
     
            e.printStackTrace();
        }finally {
     
            lock.unlock();
        }

    }

    public void printB(){
     
        lock.lock();
        try {
     
            // 判断等待，业务，唤醒
            while (number != 2){
     
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"==>BBBBBBBB"); //业务
            number = 3;
            // 唤醒指定的人（线程）B
            condition3.signal();//唤醒
        }catch (Exception e){
     
            e.printStackTrace();
        }finally {
     
            lock.unlock();
        }
    }

    public void printC(){
     
        lock.lock();
        try {
     
            // 判断等待，业务，唤醒
            while (number != 3){
     
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"==>CCCCCCC"); //业务
            number = 1;
            // 唤醒指定的人（线程）B
            condition1.signal();//唤醒
        }catch (Exception e){
     
            e.printStackTrace();
        }finally {
     
            lock.unlock();
        }
    }

}

8、八锁现象

锁是什么，如何判断锁的是谁?
8锁，就是关于锁的8个问题

8.1 问题1与问题2

问题一：标准情况下，下面的AB两个线程哪个先执行？发消息？ or 打电话？
问题一答：总是先执行发消息send() 再执行打电话call()。（为什么？如果你认为是顺序在前？这个答案是错误的！）
问题二：让send() 方法休眠4s，此时AB两个线程哪个先执行？
问题二答：还是先执行发消息send() 再执行打电话call()
为什么：
- 因为，使用synchronized加锁，synchronized 锁的对象是方法的调用者! 两个方法用的是同一个锁，谁先拿到谁执行，AB两个线程里面的方法是同一个对象调用的（这也是synchronized锁的特性，两个线程，线程A和线程B，如果当前线程A获得锁，线程B线程等待。如果线程A阻塞，线程B则会一直等待下去）

package com.wlw.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，就是关于锁的8个问题
 * 问题1.标准情况下，下面的AB两个线程哪个先执行？ 发消息？ or 打电话？
 */
public class Test1 {
     
    public static void main(String[] args) {
     
        Phone phone = new Phone();
        new Thread(()->{
     phone.send();},"A").start();
        //休息1s
        try {
     
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        new Thread(()->{
     phone.call();},"B").start();
    }
}
class Phone{
     
    public synchronized void send(){
     
        System.out.println("发消息");
    }
    public synchronized void call(){
     
        System.out.println("打电话");
    }
}

package com.wlw.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，就是关于锁的8个问题
 * 问题1.标准情况下，下面的AB两个线程哪个先执行？ 发消息？ or 打电话？
 * 问题2：让send() 方法休眠4s，此时AB两个线程哪个先执行？
 */
public class Test1 {
     
    public static void main(String[] args) {
     
        Phone phone = new Phone();
        new Thread(()->{
     phone.send();},"A").start();
        //休息1s
        try {
     
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        new Thread(()->{
     phone.call();},"B").start();
    }
}

class Phone{
     
    //synchronized 锁的对象是方法的调用者! .
    //两个方法用的是同一个锁， 谁先拿到谁执行。
    public synchronized void send(){
     
        //休眠4s
        try {
     
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        System.out.println("发消息");
    }
    public synchronized void call(){
     
        System.out.println("打电话");
    }
}

8.2 问题3与问题4

问题3：增加了一个普通方法后! 先执行发短信还是Hello? （调用方法的对象是同一个）
问题三回答：先执行普通方法
为什么：
- 因为，hello是一个普通方法，不受synchronized锁的影响
问题4：两个对象，两个同步方法，分两个线程执行，发短信还是打电话?
问题四答：先打电话，（发短信的休眠了4秒，如果没有休眠，应该是看代码执行顺序）
为什么：
- 先打电话，后发短信。原因：在发短信方法中延迟了4s，又因为synchronized锁的是对象，但是我们这使用的是两个对象，所以每个对象都有一把锁，所以不会造成锁的等待。正常执行

package com.wlw.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 问题3：加一个不带synchronized的普通的hello()方法，谁先执行
 */
public class Test2 {
     
    public static void main(String[] args) {
     
        Phone2 phone = new Phone2();

        new Thread(()->{
     phone.send();},"A").start();

        //休息1s
        try {
     
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }

        new Thread(()->{
     phone.hello();},"B").start();
    }

}

class Phone2{
     

    //synchronized 锁的对象是方法的调用者!
    //两个方法用的是同一个锁， 谁先拿到谁执行。
    public synchronized void send(){
     
        //休眠4s
        try {
     
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        System.out.println("发消息");
    }

    public synchronized void call(){
     
        System.out.println("打电话");
    }

    //hello是一个普通方法，不受synchronized锁的影响
    public void hello(){
     
        System.out.println("hello");
    }
}

package com.wlw.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 问题3：加一个不带synchronized的普通的hello()方法，谁先执行
 * 问题4：两个对象，两个同步方法，发短信还是 打电话?  //先打电话，后发短信。原因：在发短信方法中延迟了4s，又因为synchronized锁的是对象，但是我们这使用的是两个对象，所以每个对象都有一把锁，所以不会造成锁的等待。正常执行
 */
public class Test2 {
     
    public static void main(String[] args) {
     
        //两个对象，两个方法的调用者，两把锁
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

        new Thread(()->{
     phone1.send();},"A").start();

        //休息1s
        try {
     
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }

        new Thread(()->{
     phone2.call();},"B").start();
    }

}

class Phone2{
     

    //synchronized 锁的对象是方法的调用者!
    //两个方法用的是同一个锁， 谁先拿到谁执行。
    public synchronized void send(){
     
        //休眠4s
        try {
     
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        System.out.println("发消息");
    }

    public synchronized void call(){
     
        System.out.println("打电话");
    }

    //hello是一个普通方法，不受synchronized锁的影响
    public void hello(){
     
        System.out.println("hello");
    }
}

8.3 问题5与问题6

如果我们把synchronized的方法加上static变成静态方法！那么顺序又是怎么样的呢？
问题5：我们先来使用一个对象调用两个方法！
问题5答：先发短信,后打电话
问题6：如果我们使用两个对象调用两个方法！
问题6答：还是先发短信，后打电话
为什么：为什么加了static就始终前面一个对象先执行呢！为什么后面会等待呢？
- 原因是：对于static静态方法来说，对于整个类Class来说只有一份，对于不同的对象使用的是同一份方法，相当于这个方法是属于这个类的，如果静态static方法使用synchronized锁定，那么这个synchronized锁会锁住整个类！不管这个类多少个实例对象，对于静态的锁都只有一把锁，谁先拿到这个锁就先执行，其他的进程都需要等待！

package com.wlw.lock8;

import java.util.concurrent.TimeUnit;

/**
 *如果我们把synchronized的方法加上static变成静态方法！那么顺序又是怎么样的呢？
 * 问题5：我们先来使用一个对象调用两个方法！ 答：先发短信,后打电话
 */
public class Test3 {
     
    public static void main(String[] args) {
     
        Phone3 phone = new Phone3();
        
        new Thread(()->{
     phone.send();},"A").start();

        //休息1s
        try {
     
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }

        new Thread(()->{
     phone.call();},"B").start();
    }
}

//Phone3 这个类 只有一个唯一的 Class 对象
class Phone3{
     

    // synchronized 锁的对象是方法的调用者!
    // static 静态方法
    //类一加载就有了! 此时锁的是CLass
    public static synchronized void send(){
     
        //休眠4s
        try {
     
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        System.out.println("发消息");
    }

    public static synchronized void call(){
     
        System.out.println("打电话");
    }
}

package com.wlw.lock8;

import java.util.concurrent.TimeUnit;

/**
 *如果我们把synchronized的方法加上static变成静态方法！那么顺序又是怎么样的呢？
 * 问题5：我们先来使用一个对象调用两个方法！ 答：先发短信,后打电话
 * 问题6：如果我们使用两个对象调用两个方法！答：还是先发短信，后打电话
 */
public class Test3 {
     
    public static void main(String[] args) {
     
        //两个对象的Class类只有一个，因为加了static，锁的是Class（而不是具体的对象）
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();

        new Thread(()->{
     phone1.send();},"A").start();

        //休息1s
        try {
     
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }

        new Thread(()->{
     phone2.call();},"B").start();
    }
}

//Phone3 这个类 只有一个唯一的 Class 对象
class Phone3{
     

    // synchronized 锁的对象是方法的调用者!
    // static 静态方法
    //类一加载就有了! 此时锁的是CLass
    public static synchronized void send(){
     
        //休眠4s
        try {
     
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        System.out.println("发消息");
    }

    public static synchronized void call(){
     
        System.out.println("打电话");
    }
}

8.4问题7与问题8

问题7：如果我们使用一个静态同步方法（加static）、一个同步方法（不加static）、一个对象调用顺序是什么？
问题7答：先打电话，后发短信了。
为什么：
- 原因：因为一个锁的是Class类模板，一个锁的是对象调用者。后面那个打电话不需要等待发短信，直接运行就可以了。（有两把锁，和问题四类似）
问题8：如果我们使用一个静态同步方法、一个同步方法、两个对象调用顺序是什么呢？
问题8答：先打电话、后发短信！
为什么：
- 原因：因为两个对象，一样的原因，两把锁锁的不是同一个东西，所以后面的第二个对象不需要等待第一个对象的执行。

package com.wlw.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 问题7：如果我们使用一个静态同步方法（加static）、一个同步方法（不加static）、一个对象调用顺序是什么？
 *  先打电话，后发短信了。
 */
public class Test4 {
     
    public static void main(String[] args) {
     

        Phone4 phone = new Phone4();

        new Thread(()->{
     phone.send();},"A").start();

        //休息1s
        try {
     
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }

        new Thread(()->{
     phone.call();},"B").start();
    }

}

//Phone3 这个类 只有一个唯一的 Class 对象
class Phone4{
     

    // synchronized 锁的对象是方法的调用者!
    // static 静态方法
    //类一加载就有了! 此时锁的是Class模板 (只有一个)
    public static synchronized void send(){
     
        //休眠4s
        try {
     
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        System.out.println("发消息");
    }

    //普通的同步方法，锁的是 具体的类的实例对象
    public synchronized void call(){
     
        System.out.println("打电话");
    }

}

package com.wlw.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 问题7：如果我们使用一个静态同步方法（加static）、一个同步方法（不加static）、一个对象调用顺序是什么？
 *  先打电话，后发短信了。
 *问题8：如果我们使用一个静态同步方法、一个同步方法、两个对象调用顺序是什么呢？
 * 先打电话，后发短信了。
 */
public class Test4 {
     
    public static void main(String[] args) {
     

        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();

        new Thread(()->{
     phone1.send();},"A").start();

        //休息1s
        try {
     
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }

        new Thread(()->{
     phone2.call();},"B").start();
    }

}

//Phone3 这个类 只有一个唯一的 Class 对象
class Phone4{
     

    // synchronized 锁的对象是方法的调用者!
    // static 静态方法
    //类一加载就有了! 此时锁的是Class模板 (只有一个)
    public static synchronized void send(){
     
        //休眠4s
        try {
     
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        System.out.println("发消息");
    }

    //普通的同步方法，锁的是 具体的类的实例对象
    public synchronized void call(){
     
        System.out.println("打电话");
    }

}

8.5小结

锁的是什么东西？
- 只加synchronized的同步方法，锁的是 new出来的实例对象
- 加了static的synchronized同步方法。锁的是一个类的Class类模板

9.线程安全与不安全的集合

此部分查看 https://blog.csdn.net/wang_luwei/article/details/107490131

9.1List中的不安全 (ArrayList 是不安全的)

package com.wlw.unsafe;

import java.util.ArrayList;
import java.util.UUID;

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

解决方案

package com.wlw.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.locks.Condition;

//Exception in thread "3" java.util.ConcurrentModificationException 并发修改异常

/**
 * 解决方案：
 * 1. List List = new Vector<>();
 * 2.List List = Collections.synchronizedList(new ArrayList<>());
 * 3. List list = new CopyOnWriteArrayList();（这是juc包下的）
 *  
 * CopyonWrite 写入时复制 cow 计算机程序设计领域的一种优化策略
 * 多个线程调用的时候，list是唯一的,在读取的时候是固定的，在写入的时候(可能存在覆盖操作)，这种覆盖操作怎么解决？
 *  就是在写入的时候复制一份，复制完给调用者，调用者写完之后再放入原本的集合中
 *  就是在写入的时候避免覆盖，造成数据问题!
 *  读写分离的思想
 *  CopyonWriteArrayList比vector 优秀在哪里?  Vector底层是使用synchronized关键字来实现的：效率特别低下。 CopyOnWriteArrayList使用的是Lock锁，效率会更加高效！
 */
public class ListTest {
     
    public static void main(String[] args) {
     
        //List List = new ArrayList();
        List list = new CopyOnWriteArrayList<String>();

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

9.2 set 中的不安全

package com.wlw.unsafe;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 *和List一样 并发修改异常  Exception in thread "18" java.util.ConcurrentModificationException
 *解决方案:
 * 1.Set set = Collections.synchronizedSet(new HashSet<>());
 * 2.Set set = new CopyOnWriteArraySet<>();  (juc包下的类)
 */
public class SetTest {
     
    public static void main(String[] args) {
     
        //Set set = new HashSet<>();
        //Set set = Collections.synchronizedSet(new HashSet<>());
        Set<String> set = new CopyOnWriteArraySet<>();

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

9.3 map中的不安全

package com.wlw.unsafe;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

/**
 *  多线程使用HashMap()也会 造成  java.util.ConcurrentModificationException （并发修改异常）
 *  解决方案:
 *  1.Map map = Collections.synchronizedMap( new HashMap<>());
 *  2. Map map = new ConcurrentHashMap<>();  (juc包下的类)
 */
public class MapTest {
     

    public static void main(String[] args) {
     
        //map 是这样用的吗？  不是，工作中不使用 HashMap()
        //默认等价什么？ new HashMap<>(16,0.75);加载因子为0.75、初始化容量16
        //Map map = new HashMap<>();
        //Map map = Collections.synchronizedMap( new HashMap<>());
        Map<String, String> map = new ConcurrentHashMap<>();
        for (int i = 1; i <30; i++) {
     
            new Thread(()->{
     
                map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

9.4阻塞队列（BlockingQueue接口）

什么情况我们会使用阻塞队列呢？多线程并发处理、线程池！
操作：添加、移除（四组API）

方式	抛出异常	不会抛出异常，有返回值	阻塞等待	超时等待
添加	add	offer	put	offer(e,timenum，timeUnit)
移除	remove	poll	take	poll(timenum，timeUnit)
判断队列首	element	peek	-	-

package com.wlw.BQ;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

public class Test {
     
    public static void main(String[] args) throws InterruptedException {
     
        test1();
        test2();
        test3();
        test4();
    }

    //会直接在控制台抛出异常的方法
    //抛异常，有返回值
    public static void test1(){
     
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);

        System.out.println(arrayBlockingQueue.add("a"));
        System.out.println(arrayBlockingQueue.add("b"));
        System.out.println(arrayBlockingQueue.add("c"));

        //最多就能放3个，java.lang.IllegalStateException: Queue full
        //System.out.println(arrayBlockingQueue.add("d"));

        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());

        //队列空的时候，再移除就报异常 java.util.NoSuchElementException
        System.out.println(arrayBlockingQueue.remove());

    }
    /**
     * 不抛出异常，有返回值
     */
    public static void test2(){
     
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
        //添加 一个不能添加的元素 使用offer只会返回false 不会抛出异常
        System.out.println(blockingQueue.offer("d"));

        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        //弹出 如果没有元素 只会返回null 不会抛出异常
        System.out.println(blockingQueue.poll());
    }

    /**
     * 等待 一直阻塞
     */
    public static void test3() throws InterruptedException {
     
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

        //一直阻塞 不会返回
        blockingQueue.put("a");
        blockingQueue.put("b");
        blockingQueue.put("c");

        //如果队列已经满了， 再进去一个元素  这种情况会一直等待这个队列 什么时候有了位置再进去，程序不会停止
        //blockingQueue.put("d");

        System.out.println(blockingQueue.take()); //有返回值
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        //如果我们再来一个  这种情况也会等待，程序会一直运行 阻塞
        System.out.println(blockingQueue.take());
    }

    /**
     * 等待 超时阻塞
     *  这种情况也会等待队列有位置 或者有产品 但是会超时结束
     *
     */
    public static void test4() throws InterruptedException {
     
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

        blockingQueue.offer("a");
        blockingQueue.offer("b");
        blockingQueue.offer("c");
        System.out.println("开始等待");
        blockingQueue.offer("d",2, TimeUnit.SECONDS);  //超时时间2s 等待如果超过2s就结束等待
        System.out.println("结束等待");

        System.out.println("===========取值==================");
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println("开始等待");
        blockingQueue.poll(2,TimeUnit.SECONDS); //超过两秒 我们就不要等待了
        System.out.println("结束等待");
    }
}

9.4.1SynchronousQueue同步队列

同步队列没有容量，也可以视为容量为1的队列；
进去一个元素，必须等待取出来之后，才能再往里面放入一个元素；
put方法和 take方法；
SynchronousQueue 和其他的BlockingQueue 不一样它不存储元素；
put了一个元素，就必须从里面先take出来，否则不能再put进去值！

package com.wlw.BQ;

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/**
 * 同步队列和其他的BlockingQueue不一样，
 * SynchronousQueue不存储元素
 * put了一个元素，必须从里面先take取出来，否则不能再put进去值!
 */
public class SynchronousQueueDemo {
     
    public static void main(String[] args) {
     
        SynchronousQueue<String> stringSynchronousQueue = new SynchronousQueue<>();

        new Thread(()->{
     
            try {
     
                System.out.println(Thread.currentThread().getName()+"put a");
                stringSynchronousQueue.put("a");
                System.out.println(Thread.currentThread().getName()+"put b");
                stringSynchronousQueue.put("b");
                System.out.println(Thread.currentThread().getName()+"put c");
                stringSynchronousQueue.put("c");
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
        },"T1").start();

        new Thread(()->{
     
            try {
     
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"take a");
                stringSynchronousQueue.take();

                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"take b");
                stringSynchronousQueue.take();

                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"take c");
                stringSynchronousQueue.take();
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
        },"T2").start();
    }
}

10.Callable(简单)

此部分可以参考https://blog.csdn.net/wang_luwei/article/details/107490047

创建线程的第三种方式
Callable ：可以有返回值；可以抛出异常；与Runnable中的方法不同，run()/call()
两个细节：有缓存、结果需要等待（会阻塞）

package com.wlw.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableTest {
     

    public static void main(String[] args) throws ExecutionException, InterruptedException {
     

        //Callable怎么放入到Thread里面呢？
        //对于Thread运行，只能传入Runnable类型的参数； 我们这是Callable 怎么办呢？
        //在Runnable里面有一个叫做FutureTask的实现类，FutureTask中可以接受Callable参数；
        //这样我们就可以先把Callable 放入到FutureTask中， 再把FutureTask 放入到Thread就可以了。
        //new Thread(new Runnable()).start();
        //new Thread(new FutureTask<>( Callable)).start();

        MyThread myThread = new MyThread();
        FutureTask futureTask = new FutureTask(myThread);
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start(); //这两个线程只输出了一个call，结果会被缓存，效率高

        Integer o = (Integer)futureTask.get(); 
         //这个get方法可能会被阻塞，如果在cal1方法中是一个耗时的方法，所以一般情况我们会把这个放在最后，或者使用异步通信

        System.out.println(o);
    }
}

class MyThread implements Callable<Integer>{
     

    @Override
    public Integer call() throws Exception {
     
        System.out.println("call");
        return 1024;
    }
}

11.常用的辅助类

11.1 CountDownLatch

其实就是一个减法计数器，对于计数器归零之后再进行后面的操作，这是一个计数器！

package com.wlw.add;

import java.util.concurrent.CountDownLatch;

//减法计数器
//有必须要在一些任务完成之后才能执行的任务（注意顺序），再使用这个类
public class CountDownLatchDemo {
     

    public static void main(String[] args) throws InterruptedException {
     
        /**
         * 案例： 教室里有6个学生，只有当6个学生全都走了，才能关门
         */
        CountDownLatch countDownLatch = new CountDownLatch(6); //总数为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个学生全都走了，再执关门，如果没这一句关门这个操作可能会在任意时候执行）

        System.out.println("Close Door");
    }
}

原理:
- countDownLatch. countDown（）; 数量-1
- countDownLatch. await（）; /等待计数器归零,然后再向下执行
- 每次有线程调用countDown()数量-1 ,假设计数器变为0 , countDownLatch.await()就会被唤醒,继续执行!

11.2 CyclicBarrier

加法计数器

package com.wlw.add;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

//加法计数器
public class CyclicBarrierDemo {
     

    public static void main(String[] args) {
     
        /**
         * 案例：集齐7颗龙珠，召唤神龙
         */
        //设定计数器要累计的条件，还有达到条件后要执行的任务
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, new Runnable() {
     
            @Override
            public void run() {
     
                System.out.println("召唤神龙，噢噢噢噢哦哦哦~~~~~~");
            }
        });

        for (int i = 1; i <= 7; i++) {
     
            final int temp = i;
            new Thread(()->{
     
                System.out.println(Thread.currentThread().getName()+"收集了第"+temp+"颗龙珠");
                try {
     
                    cyclicBarrier.await(); // 等待计数器达到设定的条件，再执行后续操作 （即等待收集7颗龙珠后，才能召唤神龙）
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
     
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

11.3 Semaphore

Semaphore：信号量

package com.wlw.add;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreDemo {
     
    public static void main(String[] args) {
     
        //案例：6辆车，只有3个车位 ，   Semaphore来定义线程数量（可用于限流）
        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(2);
                    System.out.println(Thread.currentThread().getName()+"离开车位");
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                }finally {
     
                    semaphore.release();//释放许可证  （离开了 车位就要被释放）
                }
            },String.valueOf(i)).start();
        }
    }
}

原理：
- semaphore.acquire()获得资源，如果资源已经使用完了，就等待资源释放后再进行使用！（信号量-1）
- semaphore.release()释放，会将当前的信号量释放+1，然后唤醒等待的线程！
作用：多个共享资源互斥的使用！并发限流，控制最大的线程数！

12.读写锁ReadWritelock

此部分可以参考https://blog.csdn.net/wang_luwei/article/details/107490047

ReadWriteLock它只是一个接口， ReentrantReadWriteLock是ReadWriteLock的实现类
互斥规则：
- ReadwriteLock
  读-读可以共存!
  读-写不能共存!
  写-写不能共存!
- 独占锁(写锁) 一次只能被一个线程占有
- 共享锁(读锁) 多个线程可以同时占有
ReentrantReadWriteLock 中有两个方法：
- writeLock() 获取到写锁（writeLock()方法返回用于写入操作的锁。类型是ReentrantReadWriteLock.WriteLock，它实现了Lock接口）
- readLock() 获取到读锁（readLock()方法返回用于读取操作的锁。类型是ReentrantReadWriteLock.ReadLock，它实现了Lock接口）
Lock也是一个接口，它的实现类有ReentrantLock(最常用), ReentrantReadWriteLock.ReadLock, ReentrantReadWriteLock.WriteLock

package com.wlw.rw;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

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

        //多个线程写入
        for (int i = 1; i <= 5; i++) {
     
            final int temp = i;
            new Thread(()->{
     
                myCache.put(temp+"",temp+"");
            }).start();
        }

        //多个线程读取
        for (int i = 1; i <= 5; i++) {
     
            final int temp = i;
            new Thread(()->{
     
                myCache.get(temp+"");
            }).start();
        }
    }
}

//我们想要实现 写入的时候只能一个线程同时写入，读取可以线程同时读取
//我们也可以采用synchronized这种重量锁和轻量锁 lock去保证数据的可靠。
//但是这次我们采用更细粒度的锁：ReadWriteLock 读写锁来保证
class MyCacheReadWriteLock {
     
    //读写锁 ReadWriteLock它只是一个接口， ReentrantReadWriteLock是ReadWriteLock的实现类
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private Lock lock = new ReentrantLock(); //这只是一个普通的锁

    private volatile Map<String,String> map=new HashMap<>();

    //写入 （这是一个原子操作）只希望同时只有一个线程写
    public void put(String key,String value){
     
        // readWriteLock.writeLock() 获取到写锁 （writeLock()方法返回用于写入操作的锁。类型是ReentrantReadWriteLock.WriteLock，它实现了Lock接口）
        //lock()  上锁
        readWriteLock.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 {
     
            readWriteLock.writeLock().unlock(); //解锁
        }

    }

    //读取，所有都可以读
    public void get(String key) {
     
        // readWriteLock.readLock() 获取到读锁 （readLock()方法返回用于读取操作的锁。类型是ReentrantReadWriteLock.ReadLock，它实现了Lock接口）
        readWriteLock.readLock().lock(); //上锁
        try {
     
            //获取
            System.out.println(Thread.currentThread().getName() + " 线程 开始读取");
            String o = map.get(key);
            System.out.println(Thread.currentThread().getName() + " 线程 读取OK");
        } catch (Exception e) {
     
            e.printStackTrace();
        } finally {
     
            readWriteLock.readLock().unlock();//解锁
        }

    }

}

//不加锁 ，多线程的读写会造成数据不可靠的问题。
class MyCache{
     
    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()+" 线程 开始读取");
        String o = map.get(key);
        System.out.println(Thread.currentThread().getName()+" 线程 读取OK");

    }
}

13.线程池

此部分可以参考https://blog.csdn.net/wang_luwei/article/details/107490047

线程池：三大方法、7大参数、4种拒绝策略
池化技术
- 程序的运行，本质：占用系统的资源！我们需要去优化资源的使用 ===> 池化技术
- 线程池、JDBC的连接池、内存池、对象池等等。。。。
- 资源的创建、销毁十分消耗资源
- 池化技术：事先准备好一些资源，如果有人要用，就来我这里拿，用完之后还给我，以此来提高效率。
线程池的好处：
- 1、降低资源的消耗；
- 2、提高响应的速度；
- 3、方便管理；
线程池的作用：线程复用、可以控制最大并发数、管理线程；

13.1三大方法

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

package com.wlw.pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo01 {
     
    public static void main(String[] args) {
     
        //ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
        //ExecutorService threadPool = Executors.newFixedThreadPool(5);//创建一个固定大小的线程池
        ExecutorService threadPool = Executors.newCachedThreadPool(); //可伸缩的

        try {
     
            for (int i = 0; i < 20; i++) {
     
                //使用线程池来创建线程
                threadPool.execute(new Runnable() {
     
                    @Override
                    public void run() {
     
                        System.out.println(Thread.currentThread().getName()+"ok");
                    }
                });
            }
        } catch (Exception e) {
     
            e.printStackTrace();
        } finally {
     
            //线程池用完必须要关闭线程池
            threadPool.shutdown();
        }
    }
}

13.2七大参数

源码分析

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

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

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

本质：三种方法都是开启的ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,  //核心线程池大小
                          int maximumPoolSize, //最大的线程池大小
                          long keepAliveTime,  //超时了没有人调用就会释放
                          TimeUnit unit, //超时单位
                          BlockingQueue<Runnable> workQueue, //阻塞队列
                          ThreadFactory threadFactory, //线程工厂 创建线程的 一般不用动
                          RejectedExecutionHandler handler //拒绝策略
                         ) {
     
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

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

七个参数的说明
- 要说明的是当银行人满了的时候，就会执行拒绝策略，不再让顾客入内
- 非核心（Core）线程，如果超过设定的时间还没有被使用，就会关闭

13.3四种拒绝策略

这是七大参数中最后一个参数：拒绝策略的类型

13.3.1 new ThreadPoolExecutor.AbortPolicy()

该拒绝策略为：整个线程池满了，还有线程进来，不处理这个想进来的线程，并抛出异常
而判断线程池满？线程池的最大承载量为：阻塞队列+最大的线程池大小，超过报java.util.concurrent.RejectedExecutionException

13.3.2 new ThreadPoolExecutor.CallerRunsPolicy()

该拒绝策略为：哪来的去哪里，让 main线程去进行处理多余的线程

13.3.3 new ThreadPoolExecutor.DiscardPolicy()

该拒绝策略为：队列满了，把多余的线程（任务）丢掉，不会抛出异常。

13.3.4 new ThreadPoolExecutor.DiscardOldestPolicy()：

该拒绝策略为：队列满了，尝试去和最早的进程竞争，不会抛出异常

13.4手动创建线程池

package com.wlw.pool;

import java.util.concurrent.*;

public class Demo01 {
     
    public static void main(String[] args) {
     
        //ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
        //ExecutorService threadPool = Executors.newFixedThreadPool(5);//创建一个固定大小的线程池
        //ExecutorService threadPool = Executors.newCachedThreadPool(); //可伸缩的

        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()); //该拒绝策略为：银行满了，还有人进来，不处理这个人的，并抛出异常

                //该线程池最大承载量为： maximumPoolSize +  BlockingQueue = 5+3 = 8
        try {
     
            for (int i = 0; i < 8; i++) {
     
                //使用线程池来创建线程
                threadPool.execute(new Runnable() {
     
                    @Override
                    public void run() {
     
                        System.out.println(Thread.currentThread().getName()+"==>ok");
                    }
                });
            }
        } catch (Exception e) {
     
            e.printStackTrace();
        } finally {
     
            //线程池用完必须要关闭线程池
            threadPool.shutdown();
        }
    }
}

13.5小结和拓展(CPU密集型和IO密集型！)

如何去设置线程池的最大大小（ maximumPoolSize）如何去设置？
利用CPU密集型和IO密集型！：
- CPU密集型：电脑的核数是几核就选择几；这个大小就是maximunPoolSize的大小
  - Runtime.getRuntime().availableProcessors() 获取cpu的核数
- I/O密集型：在程序中有15个大型任务，io十分占用资源；I/O密集型就是判断我们程序中十分耗I/O的线程数量，然后将maximunPoolSize设置成大约是最大I/O数的一倍到两倍之间。

package com.wlw.pool;
import java.util.concurrent.*;

public class Demo01 {
     
    public static void main(String[] args) {
     

        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                Runtime.getRuntime().availableProcessors(),
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()); //该拒绝策略为：银行满了，还有人进来，不处理这个人的，并抛出异常

                //该线程池最大承载量为： maximumPoolSize +  BlockingQueue = 5+3 = 8
        try {
     
            for (int i = 0; i < 8; i++) {
     
                //使用线程池来创建线程
                threadPool.execute(new Runnable() {
     
                    @Override
                    public void run() {
     
                        System.out.println(Thread.currentThread().getName()+"==>ok");
                    }
                });
            }
        } catch (Exception e) {
     
            e.printStackTrace();
        } finally {
     
            //线程池用完必须要关闭线程池
            threadPool.shutdown();
        }
    }
}

14 .四大函数式接口（必需掌握）

可参考 https://blog.csdn.net/wang_luwei/article/details/107600028

https://blog.csdn.net/wang_luwei/article/details/107600001

新时代的程序员：lambda表达式、链式编程、函数式接口、Stream流式计算

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

@FunctionalInterface
public interface Runnable {
       
    public abstract void run();
}

//Java中 超级多的@FunctionalInterface
//简化编程模型，在新版本的框架底层大量应用
//foreach()的参数也是一个函数式接口，消费者类的函数式接口

函数式接口	参数类型	返回类型	说明
Consumer 消费型接口	T	void	void accept(T t); 对类型为T的对象应用操作
Supplier 供给型接口	无	T	T get(); 返回类型为T的对象
Function 函数型接口	T	R	R apply(T t); 对类型为T的对象应用操作，并返回类型为R类型的对象。
Predicate 断言型接口	T	boolean	boolean test(T t); 确定类型为T的对象是否满足条件，并返回boolean类型。

14.1 Function 函数型接口

package com.wlw.function;

import java.util.function.Function;
//Function函数型接口，有一个输入参数，有一个方法返回值类型
public class Demo1 {
     
    public static void main(String[] args) {
     
        /*Function function = new Function() {
            @Override
            public String apply(String s) {
                return s;
            }
        };*/

        //lambada表达式简化
        Function<String,String> function = (s)->{
     return s;};
        System.out.println(function.apply("abc"));
    }
}

14.2Predicate断言型接口

package com.wlw.function;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
import org.w3c.dom.ls.LSOutput;

import java.util.function.Predicate;
// 断定型接口:有一个输入参数，返回值只能是布尔值!
public class Demo02 {
     

    public static void main(String[] args) {
     
        //判断字符串是否为空
/*
        Predicate predicate = new Predicate() {
            @Override
            public boolean test(String s) {
                return s.isEmpty();
            }
        };
*/
        Predicate<String> predicate = (s)->{
     return s.isEmpty();};
        System.out.println(predicate.test(""));
    }
}

14.3Consummer 消费型接口

package com.wlw.function;

import java.util.function.Consumer;
//消费型接口：只有输入，没有返回值
public class Demo03 {
     
    public static void main(String[] args) {
     
      /* Consumer consumer = new Consumer() {
           @Override
           public void accept(String o) {
               System.out.println(o);
           }
       };*/

        Consumer<String> consumer = (o)->{
      System.out.println(o);};
       consumer.accept("asda");
    }
}

14.4Supplier供给型接口

package com.wlw.function;

import java.util.function.Supplier;
// 供给型接口， 没有参数，只有返回值
public class Demo04 {
     
    public static void main(String[] args) {
     
        /*Supplier supplier = new Supplier() {
            @Override
            public Integer get() {
                return 1024;
            }
        };*/

        Supplier supplier = ()->{
     return 1024;};
        System.out.println(supplier.get());
    }
}

15.Stream流式计算

可参考https://blog.csdn.net/wang_luwei/article/details/107600053

https://blog.csdn.net/wang_luwei/article/details/107600041

什么是Stream流式计算？
- 存储+计算！
- 存储：集合、MySQL
- 计算：流式计算~

package com.wlw.stream;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
     
    private int id;
    private String name;
    private int age;
}

package com.wlw.stream;

import java.util.Arrays;
import java.util.List;
/**
 题目要求:一分钟内完成此题，只能用一行代码实现 !
 * 现在有5个用户!筛选:
 * 1、ID必须是偶数
 * 2.年龄必须大于23岁
 * 3、用户名转为大写字母
 * 4.用户名字创者排序
 * 5、只输出一个用户!
 */
public class Test {
     
    public static void main(String[] args) {
     
        User user1 = new User(1,"a",21);
        User user2 = new User(2,"b",22);
        User user3 = new User(3,"c",23);
        User user4 = new User(4,"d",24);
        User user5 = new User(5,"e",25);
        User user6 = new User(6,"f",26);
        //集合就是存储
        List<User> list = Arrays.asList(user1, user2, user3, user4, user5, user6);

        //计算交给Stream流
        //链式编程
        list.stream()
                .filter((user)->{
     return user.getId()%2==0;})
                .filter((user)->{
     return user.getAge()>23;})
                .map((user)->{
     return user.getName().toUpperCase();})
                .sorted((u1,u2)->{
     return u2.compareTo(u1);})
                .limit(1)
                .forEach(System.out::println);
                //.forEach((user)->{System.out.println(user);});
    }
}

16.ForkJoin

什么是ForkJoin? (分支合并)
- ForkJoin 在JDK1.7，并行执行任务！提高效率~。在大数据量速率会更快！
- 大数据中：MapReduce 核心思想->把大任务拆分为小任务！

ForkJoin 的特点：工作窃取！
- 实现原理是：双端队列！从上面和下面都可以去拿到任务进行执行！

16.1如何使用ForkJoin?

通过ForkJoinPool来执行
计算任务forkjoinPool. execute(ForkJoinTask task)

package com.wlw.forkjoin;

import java.util.concurrent.RecursiveTask;

public class ForkJoinDemo extends RecursiveTask<Long> {
     

    private Long start;
    private Long end;

    //临界值
    private Long temp = 10000L;

    public ForkJoinDemo(Long start, Long end) {
     
        this.start = start;
        this.end = end;
    }

    //计算方法
    @Override
    protected Long compute() {
     
        if((end - start) < temp){
     
            Long sum = 0L;
            for (Long i = start;i <= end ; i++){
     
                sum = sum + i;
            }
            return sum;
        }else {
     
            //使用forkjoin  分而治之 计算
            Long middle = (start+end)/2;
            //拆分任务，把线程任务压入线程队列
            ForkJoinDemo forkJoinDemoTask1 = new ForkJoinDemo(start, middle);
            forkJoinDemoTask1.fork();
            //拆分任务，把线程任务压入线程队列
            ForkJoinDemo forkJoinDemoTask2 = new ForkJoinDemo(middle+1, end);
            forkJoinDemoTask2.fork();

            //获取结果
            Long sum = forkJoinDemoTask1.join() + forkJoinDemoTask2.join();
            return sum;
        }
    }
}

package com.wlw.forkjoin;

import java.util.OptionalLong;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;

public class Test {
     
    public static void main(String[] args) throws ExecutionException, InterruptedException {
     
        //test1(); //sum=500000000500000000,时间：8598
        //test2(); //sum=500000000500000000,时间：4835
        test3(); //sum=500000000500000000时间：512
    }

    public static void test1(){
     
        Long start = System.currentTimeMillis();
        Long sum = 0L;
        for (Long i = 0L;i <= 10_0000_0000L; i++){
     
            sum = sum + i;
        }
        Long end = System.currentTimeMillis();
        System.out.println("sum="+sum+",时间："+(end-start));
    }

    public static void test2() throws ExecutionException, InterruptedException {
     
        Long start = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinDemo forkJoinDemoTask = new ForkJoinDemo(0L,10_0000_0000L);
        ForkJoinTask<Long> submit = forkJoinPool.submit(forkJoinDemoTask);
        Long aLong = submit.get();
        Long end = System.currentTimeMillis();
        System.out.println("sum="+aLong+",时间："+(end-start));
    }

    public static void test3(){
     
        Long start = System.currentTimeMillis();
        //使用Stream
        Long sum = LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0,(x,y)->{
     return x+y;});

        Long end = System.currentTimeMillis();
        System.out.println("sum="+sum+"时间："+(end-start));
    }
}

17.异步回调

Future 设计的初衷：对将来的某个事件结果进行建模！
异步回调，我们可以想到 ajax（前端 --> 发送ajax异步请求给后端）
看一下jdk文档

17.1没有返回值的 runAsync() 异步回调

package com.wlw.future;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

/**
 *异步调用: CompletableFuture
 *   异步执行.
 *   成功回调
 *   失败回调
 */

public class Demo01 {
     
    public static void main(String[] args) throws ExecutionException, InterruptedException {
     
        //发送一个请求，采用的是无返回值的 runAsync() 异步回调
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(()->{
     
            try {
     
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"==>runAsync 无返回值的异步回调 void");
        });

        System.out.println("1111111111111111");

        completableFuture.get(); //阻塞 的获取等待结果 ，它会等待发送请求之后的执行结果,但是并不影响其他代码的执行
    }
}

17.1有返回值的supplyAsync() 异步回调

package com.wlw.future;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class Demo02 {
     
    public static void main(String[] args) throws ExecutionException, InterruptedException {
     
        //有返回值的supplyAsync() 异步回调
        //分为成功和失败的回调
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
     
            System.out.println(Thread.currentThread().getName()+"==>supplyAsync 有返回值的异步回调 Integer");
            int a = 10/0;
            return 1024;
        });

        System.out.println(completableFuture.whenComplete((t, u) -> {
     
            System.out.println("t==>" + t);  //成功回调，得到的正常的返回结果
            System.out.println("u==>" + u); //  抛出异常的 输出的错误信息  u==>java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
        }).exceptionally((e) -> {
     
            System.out.println(e.getMessage());
            return 233; //获取到错误的返回结果
        }).get());
    }
}

18.JMM

JMM （java memory model）即为JAVA 内存模型，不存在的东西，是一个概念，也是一个约定！
关于JMM的一些同步的约定：
- 1、线程解锁前，必须把共享变量立刻刷回主存；
- 2、线程加锁前，必须读取主存中的最新值到工作内存中；
- 3、加锁和解锁是同一把锁；

18.1什么是JMM

JMM即为JAVA 内存模型（java memory model）。因为在不同的硬件生产商和不同的操作系统下，内存的访问逻辑有一定的差异，结果就是当你的代码在某个系统环境下运行良好，并且线程安全，但是换了个系统就出现各种问题。Java内存模型，就是为了屏蔽系统和硬件的差异，让一套代码在不同平台下能到达相同的访问结果。JMM从java 5开始的JSR-133发布后，已经成熟和完善起来。

18.2内存划分

JMM规定了内存主要划分为主内存和工作内存两种。此处的主内存和工作内存跟JVM内存划分（堆、栈、方法区）是在不同的层次上进行的，如果非要对应起来，主内存对应的是Java堆中的对象实例部分，工作内存对应的是栈中的部分区域，从更底层的来说，主内存对应的是硬件的物理内存，工作内存对应的是寄存器和高速缓存。

JVM在设计时候考虑到，如果JAVA线程每次读取和写入变量都直接操作主内存，对性能影响比较大，所以每条线程拥有各自的工作内存，工作内存中的变量是主内存中的一份拷贝，线程对变量的读取和写入，直接在工作内存中操作，而不能直接去操作主内存中的变量。但是这样就会出现一个问题，当一个线程修改了自己工作内存中变量，对其他线程是不可见的，会导致线程不安全的问题。因为JMM制定了一套标准来保证开发者在编写多线程程序的时候，能够控制什么时候内存会被同步给其他线程。

遇到问题：程序不知道主存中的值已经被修改过了！；

18.3内存交互操作

内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类型的变量来说，load、store、read和write操作在某些平台上允许例外）
- lock(锁定)：作用于主内存的变量，把一个变量标识为线程独占状态
- unlock(解锁)：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
- read(读取)：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用
- load(载入)：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中
- use(使用)：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令
- assign(赋值)：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中
- store(存储)：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用
- write(写入)：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中
JMM对这八种指令的使用，制定了如下规则：
- 不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
- 不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
- 不允许一个线程将没有assign的数据从工作内存同步回主内存
- 一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作
- 一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
- 如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
- 如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
- 对一个变量进行unlock操作之前，必须把此变量同步回主内存

19.Volatile

Volatile 是 Java 虚拟机提供 轻量级的同步机制，他的三大特性：
- 1、保证可见性（这就要涉及JMM）
- 2、不保证原子性
- 3、禁止指令重排
下面我们来验证三个特性

19.1 验证保证可见性

package com.wlw.Test_Volatile;
import java.util.concurrent.TimeUnit;

public class JMMDemo {
     
    /**
     * 这个程序一共有两个线程： main线程 与 我们自己写的一个A线程
     * A线程中对变量num 进行判断，如果为0，就一直循环，而main线程中将num 赋值为1，此时我们没有对变量num加volatile关键字，A线程一直循环下去
     *
     * 如果我们对变量num加volatile关键字，就保证了可见性：当main线程中对num进行修改，A线程可以看见修改后的值，进而进行相关操作
     */
    private volatile static int num = 0;

    public static void main(String[] args) {
     

        new Thread(()->{
     
            while (num == 0){
     

            }
        },"A").start();

        try {
     
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }

        num = 1;
        System.out.println(num);
    }
}

19.2 验证不保证原子性

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

package com.wlw.Test_Volatile;

//volatile 不保证原子性

/**
 * 一共20个线程，每个线程调用1000次add()方法，理论上num最后为20000
 * 但是多线程操作，会出现同一时刻多个线程对num进行操作（因为在字节码文件中num++ 这个操作被分为三步才执行完，不是原子操作），所以最后的值小于2万
 *
 * ，加上volatile关键字之后，最后num结果依然小于20000，所以验证了  volatile 不保证原子性。
 * 但是如果我们对add()方法 加上synchronized 或者 lock锁，是一定可以保证结果为2万的，
 * 但是问题是如果不加lock和synchronized （更耗费资源） ，怎么样保证原子性？
 */
public class VolatileDemo02 {
     

    private volatile static int num = 0;

    public static void add(){
     
        num++;
    }

    public static void main(String[] args) {
     
        // 一共20个线程，每个线程调用1000次add()方法，理论上num最后为20000
        for (int i = 1; i <= 20; i++) {
     
            new Thread(()->{
     
                for (int j = 1; j < 1000; j++) {
     
                    add();
                }
                add();
            }).start();
        }

        while (Thread.activeCount() > 2){
     
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + "==>" + num);
    }
}

问题：如果我们对add()方法加上synchronized 或者 lock锁，是一定可以保证结果为2万的，但是问题是如果不加lock和synchronized （更耗费资源），怎么样保证原子性？
解决：使用 java.util.concurrent.atomic(原子包) 包下的原子类
- 这些类的底层都直接和操作系统挂钩！是在内存中修改值。需要用到Unsafe类，而Unsafe类是一个很特殊的存在；（在21.CAS中介绍）

package com.wlw.Test_Volatile;

//volatile 不保证原子性

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 一共20个线程，每个线程调用1000次add()方法，理论上num最后为20000
 * 但是多线程操作，会出现同一时刻多个线程对num进行操作（因为在字节码文件中num++ 这个操作被分为三步才执行完，不是原子操作），所以最后的值小于2万
 * ，加上volatile关键字之后，最后num结果依然小于20000，所以 验证了  volatile 不保证原子性。
 * 但是如果我们对add()方法 加上synchronized 或者 lock锁，是一定可以保证结果为2万的，
 * 但是问题是如果不加lock和synchronized （更耗费资源） ，怎么样保证原子性？
 *   解决办法：使用 java.util.concurrent.atomic(原子包) 包下的原子类
 */
public class VolatileDemo02 {
     

    //private static int num = 0;
    //使用原子类AtomicInteger 替换int
    private volatile static AtomicInteger num = new AtomicInteger();

    public static void add(){
     
        //num++;
        num.getAndIncrement();//原子类的加1操作 , 里面是调用的是native方法, 用的是底层的CAS（cpu的并发原语，效率极高）
    }

    public static void main(String[] args) {
     
        // 一共20个线程，每个线程调用1000次add()方法，理论上num最后为20000
        for (int i = 1; i <= 20; i++) {
     
            new Thread(()->{
     
                for (int j = 1; j < 1000; j++) {
     
                    add();
                }
                add();
            }).start();
        }

        while (Thread.activeCount() > 2){
     
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + "==>" + num);
    }
}

19.3 验证禁止指令重排

什么是指令重排？
- 我们写的程序，计算机并不是按照我们自己写的那样去执行的
- 源代码–>编译器优化重排–>指令并行也可能会重排–>内存系统也会重排–>执行
系统处理器在进行指令重排的时候，会考虑数据之间的依赖性！并不会随意地去排

int x=1; //1
int y=2; //2
x=x+5;   //3
y=x*x;   //4

//我们期望的执行顺序是 1_2_3_4  指令重排后，可能执行的顺序会变成2134 1324
//可不可能是 4123？ 不可能的

看一个例子：

可能造成的影响结果：前提：a b x y这四个值默认都是0

线程A	线程B
x=a	y=b
b=1	a=2

我们期望的正常的结果： x = 0; y =0;

线程A	线程B
b=1	a=2
x=a	y=b

可能在线程A中会出现，先执行b=1,然后再执行x=a；

在B线程中可能会出现，先执行a=2，然后执行y=b；

那么就有可能结果如下：x=2; y=1

volatile可以避免指令重排： 是因为volatile中会加一道内存的屏障，这个内存屏障可以保证在这个屏障中的指令顺序。
- 内存屏障，是CPU指令。作用：
  - 1、保证特定的操作的执行顺序；
  - 2、可以保证某些变量的内存可见性（利用这些特性，就可以保证volatile实现的可见性）

19.4小结

Volatile是可以保证可见性，不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生！
Volatile 内存屏障在哪使用最多：在单例模式中使用最多（饿汉式，DCL懒汉式中用到了Volatile）

20.单例模式

单例模式最重要一点，构造方法私有

20.1 饿汉式

package com.wlw.single;
/**
 * 饿汉式
 * 类加载时创建，天生线程安全，但是 声明周期太长，浪费空间
 */
public class Hungry {
     

    //饿汉式单例，类加载时就创建,如果有下面类似的代码，就会浪费空间
    private byte[]  data1 = new byte[1024*1024];
    private byte[]  data2 = new byte[1024*1024];
    private byte[]  data3 = new byte[1024*1024];
    private byte[]  data4 = new byte[1024*1024];

    private Hungry(){
     }
    private static final Hungry hungry = new Hungry();
    public static Hungry getInstance(){
     
        return hungry;
    }
}

20.1懒汉式

20.1.1普通懒汉式

package com.wlw.single;

/**
 * 懒汉式单例
 * 使用时创建，声明周期短，节省空间 ，但线程不安全，（可通过同步方法与同步代码块来改善）
 */
public class Lazy {
     
    private Lazy(){
     
        System.out.println(Thread.currentThread().getName()+"==> ok");
    }
    private static Lazy lazy ;

    //提供公共的获取方法,因为不是在类加载时就创建对象，因此存在线程安全问题，使用synchronized关键字保证线程安全，效率降低
    public static synchronized Lazy getInstance(){
     
        if(lazy == null){
     
            lazy = new Lazy();
        }
        return lazy;
    }

    //多线程操作,单例模式，就是只会有一个实例，而此时却有不定个，所以需要对getInstance方法加锁处理
    public static void main(String[] args) {
     
        for (int i = 0; i < 10; i++) {
     
            new Thread(()->{
     
                Lazy.getInstance();
            }).start();
        }

    }
}

20.1.2DCL懒汉式(双重检测锁模式)

package com.wlw.single;

/**
 * 懒汉式单例
 * 使用时创建，声明周期短，节省空间 ，但线程不安全，（可通过同步方法与同步代码块来改善）
 */
public class Lazy {
     
    private Lazy(){
     
        System.out.println(Thread.currentThread().getName()+"==> ok");
    }
    private volatile static Lazy lazy ;
/*
    //提供公共的获取方法,因为不是在类加载时就创建对象，因此存在线程安全问题，使用synchronized关键字保证线程安全，效率降低
    public static synchronized Lazy getInstance(){
        if(lazy == null){
            lazy = new Lazy();
        }
        return lazy;
    }

 */

    //双重检索锁模式的 懒汉式单例， DCL懒汉式
    //同样是在类加载时只提供一个引用，不会直接创建单例对象，不需要对整个方法进行同步，缩小了锁的范围，只有第一次会进入创建对象的方法，提高了效率
    public static Lazy getInstance(){
     
        if(lazy == null){
       //这一句是为了提高执行效率，不用每次都判断锁
            synchronized (Lazy.class){
      // 这个锁只有一个，因为Lazy.class只有一个
                if(lazy == null){
     
                    lazy = new Lazy(); //new 操作不是一个原子操作
                    /**
                     * 1. 分配内存空间
                     * 2、执行构造方法，初始化对象
                     * 3、把这个对象指向这个空间
                     *
                     * 我们希望是按照 123 走
                     * 但是可能出现 按照 132
                     * 假如线程A进来按照132走，走到3时，线程B进来发现已经有一个对象指向了一个空间，就认为此时lazy！=null，
                     * 所以，B就会直接走  return lazy; 而此时线程A中的Lazy还没有完成构造，就会出错。
                     * 这样的问题是有指令重排造成的，所以我们可以加上 Volatile 来禁止指令重排
                     */
                }
            }
        }
        return lazy;
    }


    //多线程操作,单例模式，就是只会有一个实例，而此时却有不定个，所以需要对getInstance方法加锁处理
    public static void main(String[] args) {
     
        for (int i = 0; i < 10; i++) {
     
            new Thread(()->{
     
                Lazy.getInstance();
            }).start();
        }

    }
}

20.1.3 静态内部类懒汉式

package com.wlw.single;

//静态内部类懒汉式
//使用静态内部类解决了线程安全问题，并实现了延时加载
public class Holder {
     
    private Holder(){
     }

    //不会在外部类初始化时就直接加载，只有当调用了getInstance方法时才会静态加载，线程安全，final保证了在内存中只有一份
    private static class InnerClass{
     
        private static final Holder hodler  = new Holder();
    }

    public static Holder getInstance(){
     
        return InnerClass.hodler;
    }
}

20.1.4枚举单例

以上的单例模式是不安全的，可以用反射来破坏

我们怎么解决呢？我们来看一下反射中的newInstance()方法（枚举不能使用反射来破坏）
枚举单例

package com.wlw.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

//enum 是什么？ enum本身就是一个Class 类
//枚举方式实现单例模式
public enum  EnumSingle {
     
    INSTANCE;

    public EnumSingle getInstance(){
     
        return INSTANCE;
    }
}

class Test{
     
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
     
        EnumSingle instance = EnumSingle.INSTANCE;

        Constructor<EnumSingle> declaredConstructors = EnumSingle.class.getDeclaredConstructor(null);
        //报错 Exception in thread "main" java.lang.NoSuchMethodException: com.wlw.single.EnumSingle.() 没有空参方法
        //如果我们看idea 编译后的文件：会发现idea骗了我们，居然告诉我们是有无参构造的，我们使用jad进行反编译。
        
        declaredConstructors.setAccessible(true); //破坏私有权限
        EnumSingle instance2 = declaredConstructors.newInstance();
        System.out.println(instance);
        System.out.println(instance2);

    }
}

如果我们看idea 编译后的文件：会发现idea骗了我们，居然告诉我们是有无参构造的，我们使用jad进行反编译。

package com.wlw.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

//enum 是什么？ enum本身就是一个Class 类
//枚举方式实现单例模式
public enum  EnumSingle {
     
    INSTANCE;

    public EnumSingle getInstance(){
     
        return INSTANCE;
    }
}

class Test{
     
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
     
        EnumSingle instance = EnumSingle.INSTANCE;

        //Constructor declaredConstructors = EnumSingle.class.getDeclaredConstructor(null);
        //报错 Exception in thread "main" java.lang.NoSuchMethodException: com.wlw.single.EnumSingle.() 没有空参方法
        //如果我们看idea 编译后的文件：会发现idea骗了我们，居然告诉我们是有无参构造的，我们使用jad进行反编译。

        //反编译之后，我们看见一个 有参构造 ，两个参数为 String ，int 类型
        Constructor<EnumSingle> declaredConstructors = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        // 此时报的错是：Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
        // 提醒我们不能用反射破坏枚举
        declaredConstructors.setAccessible(true); //破坏私有权限
        EnumSingle instance2 = declaredConstructors.newInstance();
        System.out.println(instance);
        System.out.println(instance2);

    }
}

21.CAS

21.1java层面的CAS

CAS：Compare and Swap，即比较再交换。
jdk5增加了并发包java.util.concurrent.*,其下面的类使用CAS算法实现了区别于synchronouse同步锁的一种乐观锁。JDK 5之前Java语言是靠synchronized关键字保证同步的，这是一种独占锁，也是是悲观锁。
对CAS的理解，CAS是一种无锁算法，CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。

CAS比较与交换的伪代码可以表示为：

do{
       
备份旧数据；
基于旧数据构造新数据；
}while(!CAS( 内存地址，备份的旧数据，新数据 ))

CAS（比较并交换）是CPU指令级的操作，只有一步原子操作，所以非常快

package com.wlw.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {
     
    //CAS ：compareAndSet() 这个方法的缩写 比较并交换！
    public static void main(String[] args) {
     
        //原子类的底层运用了CAS
        AtomicInteger atomicInteger = new AtomicInteger(2020);

        // public final boolean compareAndSet(int expect, int update)
        //如果我期望的值达到了，那么就更新，否则，就不更新，CAS是CPU的并发原语!
        System.out.println(atomicInteger.compareAndSet(2020, 2021)); //true
        System.out.println(atomicInteger.get()); //2021 ,atomicInteger的值更新到了2021

        System.out.println(atomicInteger.compareAndSet(2020, 2021)); //false
        System.out.println(atomicInteger.get()); //2021，此时atomicInteger的值是2021，不更新
    }
}

我们来看一下compareAndSet() 方法的源码 (AtomicInteger.java文件中)

public final boolean compareAndSet(int expect, int update) {
     
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

再往里走，看一下 unsafe.compareAndSwapInt() 方法 (这是底层的CAS ,Unsafe.class中 )

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

21.2unsafe类

来理解一下在19.2提到的原子类中说到的 unsafe 类
AtomicInteger中有个执行+1操作的方法 getAndIncrement() ，它的源码如下：

public final int getAndIncrement() {
     
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

这里有一个unsafe ，ctrl+左键，点击一下，到 AtomicInteger.java文件中

然后我们看一下unsafe.getAndAddInt(this, valueOffset, 1); 这个方法（点一下到的是C:\Program Files\Java\jdk1.8.0_144\jre\lib\rt.jar!\sun\misc\Unsafe.class中）
- this就是当前对象赋值给var1，valueoffset是内存地址偏移值赋值给var2，1就是要加的值赋值给var4，通过var1和var2获取当前对象在内存中的值赋值给var5，然后通过compareAndSwapInt （CAS比较并交换,这是一个用native修饰的方法）这个方法来判断当前对象的内存地址偏移值中对应的值如果还是var5 （我期望的值），就执行加1。
- ```
public final int getAndAddInt(Object var1, long var2, int var4) {
         
        int var5;
        do {
         
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
}

public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
```

同时，对于Unsafe类中的getAndAddInt这个方法

21.3小结

CAS：比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环，使用的是自旋锁。
CAS优点：自带原子性
CAS缺点：
- 由于使用了自旋锁，循环会耗时；
- 一次性只能保证一个共享变量的原子性；
- 它会存在ABA问题
说起CAS，就要提ABA问题（狸猫换太子）

22.原子引用解决ABA问题

22.1ABA问题

在CAS算法中，需要取出内存中某时刻的数据(由用户完成)，在下一时刻比较并交换(CPU保证原子操作)，这个时间差会导致数据的变化。假设有以下顺序事件： > 1、线程1从内存位置V中取出A > 2、线程2从内存位置V中取出A > 3、线程2进行了写操作，将B写入内存位置V > 4、线程2将A再次写入内存位置V > 5、线程1进行CAS操作，发现V中仍然是A，交换成功

尽管线程1的CAS操作成功，但线程1并不知道内存位置V的数据发生过改变

线程1：期望值是1，要把1变成2；
而线程2：进行了两个操作：
- 1、对变量A，进行了cas操作，期望值是1，变成3
- 2、之后又进行了一次cas操作，期望是3，变成1
所以对于线程1来说，A的值还是1，所以就出现了问题，骗过了线程1；

public class casDemo {
     
    //CAS : compareAndSet 比较并交换
    public static void main(String[] args) {
     
        AtomicInteger atomicInteger = new AtomicInteger(2020);
  
        //boolean compareAndSet(int expect, int update)
        //期望值、更新值
        //如果实际值 和 我的期望值相同，那么就更新
        //如果实际值 和 我的期望值不同，那么就不更新
        //===================捣乱的线程=================
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(2021, 2020));
        System.out.println(atomicInteger.get());
        
		//===================期望的线程=================
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
    }
}

22.2原子引用解决ABA问题

解决ABA问题，对应的思想：就是使用了 乐观锁
java.util.concurrent.atomic 包下有个类 AtomicReference （原子引用类），它有带版本号的原子操作！，在进行cas操作时，除了比较期望的值以外，还会比较期望的版本号，如果版本号不同，则修改失败

package com.wlw.cas;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;

public class CASDemo02 {
     
    public static void main(String[] args) {
     
        AtomicStampedReference<Integer> atomicInteger = new AtomicStampedReference<Integer>(1,1);

        new Thread(()->{
     
            int stamp = atomicInteger.getStamp(); //获取版本号
            System.out.println("a1=>"+stamp);

            try {
     
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }

            System.out.println(atomicInteger.compareAndSet(1, 2, atomicInteger.getStamp(), atomicInteger.getStamp() + 1));
            System.out.println("a2=>"+atomicInteger.getStamp());

            System.out.println(atomicInteger.compareAndSet(2, 1, atomicInteger.getStamp(), atomicInteger.getStamp() + 1));
            System.out.println("a3=>"+atomicInteger.getStamp());
        },"A").start();

        //乐观锁的原理
        new Thread(()->{
     
            int stamp = atomicInteger.getStamp(); //获取版本号
            System.out.println("b1=>"+stamp);

            try {
     
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }

            System.out.println(atomicInteger.compareAndSet(1, 6,
                    stamp, atomicInteger.getStamp() + 1)); //输出false，因为版本号不一致
            System.out.println("b2=>"+atomicInteger.getStamp());
        },"B").start();
    }
}
/*
a1=>1
b1=>1
true
a2=>2
true
a3=>3
false
b2=>3
*/

21.各种锁

21.1公平锁与非公平锁

公平锁：非常公平；不能插队的，必须先来后到；
非公平锁：非常不公平，允许插队的，可以改变顺序。(ReentrantLock 与 Synchronized 默认都是非公平锁)

/**
 * Creates an instance of {@code ReentrantLock}.
 * This is equivalent to using {@code ReentrantLock(false)}.
 */
public ReentrantLock() {
     
    sync = new NonfairSync();
}

/**
 * Creates an instance of {@code ReentrantLock} with the
 * given fairness policy.
 *
 * @param fair {@code true} if this lock should use a fair ordering policy
 */
public ReentrantLock(boolean fair) {
     
    sync = fair ? new FairSync() : new NonfairSync();
}

21.2可重入锁

可重入锁(递归锁)
- 什么是 “可重入”，可重入就是说某个线程已经获得某个锁，可以再次获取相同的锁而不会出现死锁。
- synchronized和ReentrantLock都是可重入的
- 使用ReentrantLock的注意点 : synchronized是自己释放锁的，ReentrantLock 和 synchronized 不一样，需要手动释放锁，所以使用 ReentrantLock的时候一定要手动释放锁，并且加锁次数和释放次数要一样 （否则就导致死锁）
synchronized

package com.wlw.allLock;

public class Demo01 {
     
    public static void main(String[] args) {
     
        Phone phone = new Phone();
        new Thread(()->{
     
            phone.send();
        },"A").start();

        new Thread(()->{
     
            phone.send();
        },"B").start();
    }
}
class Phone{
     

    public synchronized void send(){
     
        System.out.println(Thread.currentThread().getName()+"===》 send message");
        call();
    }

    public synchronized void call(){
     
        System.out.println(Thread.currentThread().getName()+"===》 call");
    }
}

/*
A===》 send message
A===》 call
B===》 send message
B===》 call
*/

ReentrantLock

package com.wlw.allLock;

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

public class Demo02{
     
    public static void main(String[] args) {
     
        Phone2 phone = new Phone2();
        new Thread(()->{
     
            phone.send();
        },"A").start();

        new Thread(()->{
     
            phone.send();
        },"B").start();
    }
}
class Phone2{
     

    Lock lock = new ReentrantLock();

    public void send(){
     
        lock.lock();
        try {
     
            System.out.println(Thread.currentThread().getName()+"===》 send message");
            call();
        }catch (Exception e){
     
            e.printStackTrace();
        }finally {
     
            lock.unlock();
        }

    }
    public void call(){
     
        lock.lock();
        try {
     
            System.out.println(Thread.currentThread().getName()+"===》 call");
        }catch (Exception e){
     
            e.printStackTrace();
        }finally {
     
            lock.unlock();
        }

    }
}
/*
A===》 send message
A===》 call
B===》 send message
B===》 call
*/

21.3自旋锁

spinlock自旋锁：不断的循环，不断的迭代，不断的尝试，知道成功为止
之前在原子类（AtomicInteger.getAndIncrement->unsafe.getAndAddInt）中见过自旋锁

 public final int getAndAddInt(Object var1, long var2, int var4) {
     
        int var5;
        do {
     
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
}

自己利用CAS写一个自旋锁

package com.wlw.allLock;

import java.util.concurrent.atomic.AtomicReference;
//自旋锁
public class SpinLockDemo {
     
    AtomicReference atomicReference = new AtomicReference();

    //加锁
    public void mylock(){
     
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"===> mylock");

        //自旋锁 第一个线程执行mylock方法，不会进入循环，第二线程才会进入
        while (!atomicReference.compareAndSet(null,thread)){
     

        }
    }

    //解锁
    public void myunlock(){
     
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"===> myunlock");
        //设置为null，解锁
        atomicReference.compareAndSet(thread,null);
    }
}

package com.wlw.allLock;

import java.util.concurrent.TimeUnit;

//测试自旋锁
public class TestSpinLock {
     
    public static void main(String[] args) throws InterruptedException {
     
        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(()->{
     
            spinLockDemo.mylock();
            try {
     
                TimeUnit.SECONDS.sleep(5);
            }catch (Exception e){
     
                e.printStackTrace();
            }
            finally {
     
                spinLockDemo.myunlock();
            }
        },"T1").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
     
            spinLockDemo.mylock();
            try {
     
                TimeUnit.SECONDS.sleep(5);
            }catch (Exception e){
     
                e.printStackTrace();
            }
            finally {
     
                spinLockDemo.myunlock();
            }
        },"T2").start();
    }
}
/*
T1===> mylock
T2===> mylock
T1===> myunlock
T2===> myunlock
T2进程必须等待T1进程Unlock后，才能Unlock，在这之前进行自旋等待。。。。
*/

21.4死锁

什么是死锁？
- 如果一组进程中的每一个进程都在等待仅有改组进程中的其他进程才能引发的事件，那么改组进程是死锁的
- 简单点来说，第一个线程拥有A对象锁标记，并等待B对象锁标记，同时第二个线程拥有B对象锁标记，并等待A对象锁标记时，产生死锁。（或者来说，两个进程都在等待对方释放持有的资源，而自己却不释放资源）
产生死锁的必要条件：
- 互斥条件：资源是互斥使用的
- 请求和保持条件：该线程保持自己持有的资源，去请求其他进程已经占有的资源
- 不可抢占条件：进程已获得的资源在未使用完之前不能被抢占
- 循环等待条件：发生死锁时，必然存在着一个进程——资源的循环链

package com.wlw.allLock;

public class DeadLockDemo {
     

    public static void main(String[] args) {
     

        String lockA = "lockA";
        String lockB = "lockB";

        new Thread(new MyThread(lockA,lockB),"t1").start();
        new Thread(new MyThread(lockB,lockA),"t2").start();
    }
}

class MyThread implements Runnable{
     

    private String lockA;
    private String lockB;

    public MyThread(String lockA, String lockB) {
     
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
     
        synchronized (lockA){
     
            System.out.println(Thread.currentThread().getName()+"持有"+lockA+",想要"+lockB);

            synchronized (lockB){
     
                System.out.println(Thread.currentThread().getName()+"持有"+lockB+",想要"+lockA);
            }
        }
    }
}
/*
t1持有lockA,想要lockB
t2持有lockB,想要lockA
程序就这样一直持续下去....................
*/

怎么解决死锁呢？
- 当我们发现程序出现死锁时，可以使用jdk中bin目录下有一个jps工具来定位死锁
1、使用jps定位进程号，命令 jps -l

2、使用jstack进程号 找到死锁信息
排查问题！:1、日志 , 2、堆栈信息

你可能感兴趣的:(JUC（高并发）,juc)

nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
MongoDB知识概括 GeorgeLin98 持久层 mongodb
MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
华为云分布式缓存服务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内
SpringBoot整合ES搜索引擎实现网站热搜词及热度计算码踏云端 springboot Elasticsearch spring boot elasticsearch 后端热搜词热度计算 java
博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
【仿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.负载均衡和多实例处理首先，让我们看一下描述负载均衡和多实例处理的流程图
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服务的基本功能，启用网路协议、提供运行环境、创建连
Java高并发编程详解系列-深入理解Thread构造 nihui123 高并发 Java高并发 Java 高并发
上篇分享中主要是对线程的基本概念和基本操作做了一个分享，同时提出了两种常用的创建多线程的方法，当然在后期的分享中也会提及到更多的创建线程的方式，到后期的分享的时候再说。这次主要是深入的理解一下Thread的构造函数，通过构造函数对于Thread有一个更加深入的了解。这里首先提供一个JDK1.6的ThreadAPI截图线程命名规范从源码分析可以看到在Thread类中默认提供了线程的命名方式，这个
Java高并发编程详解系列-Balking设计模式 nihui123 高并发设计模式 java 编程语言
导语在实际操作中当某个线程因为发现其他线程正在进行相同的工作而放弃即将开始的任务，这种情况就被称为是Balking模式，Balking英文的意思是犹豫。在多个线程监控某个共享变量，A线程监控到共享变量发生变化后立即触发某个动作，但是这个这个时候发现了B线程也对该变量开始了行动，这个时候A变量就放弃了准备工作。下面就来详细的讲解一下关于Balking模式什么是Balking模式在餐厅吃饭的时
Java高并发编程详解系列-Future设计模式 nihui123 高并发 Java高并发 Future 高并发
导语假设，在一个使用场景中有一个任务需要执行比较长的时间，通常需要等待任务执行结束之后或者是中途出错之后才能返回结果。在这个期间调用者只能等待，对于这个结果Future设计模式提供了一种凭据式的解决方案。在日常生活中，这种方案也是存在的。例如去洗衣店洗衣服，当你把衣服放到洗衣店，等他洗完需要一段时间，这个时候洗衣店就会给你一凭证，你可以通过这个凭证到时候去取洗好的衣服。这个例子就是生活中的Fu
论文分享系列（二）——论微服务架构及其应用马斯洛金字塔下的小灵猴儿 #软考高项架构师论微服务架构及其应用论文
论微服务架构及其应用摘要2023年5月，我司启动了精彩购电商系统的开发工作，该项目组中我担任系统架构师岗位，主要负责整体架构设计与中间件选型。本文以该电商平台为例，将介绍微服务架构的特点、应用场景以及实现方法。系统以SpringCloud微服务框架开发，分为前端Web服务、平台保障服务、业务服务三部分。前端Web服务由负载均衡与服务器集群结合，实现高并发的前台界面；平台保障服务以Eureka为中心
HBase（一）——HBase介绍 weixin_30595035 大数据数据库数据结构与算法
HBase介绍1、关系型数据库与非关系型数据库（1）关系型数据库关系型数据库最典型的数据机构是表，由二维表及其之间的联系所组成的一个数据组织优点：1、易于维护：都是使用表结构，格式一致2、使用方便：SQL语言通用，可用于复杂查询3、复杂操作：支持SQL，可用于一个表以及多个表之间非常复杂的查询缺点：1、读写性能比较差，尤其是海量数据的高效率读写2、固定的表结构，灵活度稍欠3、高并发读写需求，传统关
实现多级缓存的六种策略方法 Kixuan214 缓存 redis rabbitmq
保证多级缓存数据一致性是一个复杂的任务，尤其是在分布式和高并发环境中。以下是一些常见的方法和策略，可以帮助实现多级缓存的数据一致性1.缓存失效策略1.1主动失效在更新数据库时，主动使相关缓存失效。步骤：更新数据库删除或失效缓存publicclassCacheService{privateLocalCachelocalCache;privateRedisCacheredisCache;private
Reactive 编程-Vert.x Flying_Fish_Xuan python 开发语言
Reactive编程与Vert.x：高效异步Java微服务框架一、什么是Reactive编程？Reactive编程是一种异步编程范式，专注于数据流和事件的传播处理。与传统的阻塞式编程不同，Reactive编程能够更好地处理高并发和异步操作，特别适合实时系统、流处理以及需要快速响应的场景。Reactive编程的核心原则包括：响应性（Responsive）：系统能够快速响应用户请求，并保持低延迟。弹性
K8S - Emptydir - 取代ELK 使用fluentd 构建logging saidcar nvd11 K8S kubernetes
由于k8s的无状态service通常部署在多个POD中，实现多实例面向高并发。但是k8s本身并没有提供集中查询多个pod的日志的功能其中1个常见方案就是ELK.本文的方案是利用fluentdsidecar和emptydir把多个pod的日志导向到bigquery的table中。Emptydir的简介Kubernetes中的EmptyDir是一种用于容器之间共享临时存储的空目录卷类型。EmptyDi
Redis总结（八）redis单线程还是多线程问题卢小记
redis为什么可以支持高并发和它内部的工作模式有不可分割的关系：绝大部分请求是纯粹的内存操作（非常快速）采用单线程,避免了不必要的上下文切换和竞争条件非阻塞IO-IO多路复用Redis客户端对服务端的每次调用都经历了发送命令，执行命令，返回结果三个过程。其中执行命令阶段，由于Redis是单线程来处理命令的，所有到达服务端的命令都不会立刻执行，所有的命令都会进入一个队列中，然后逐个执行，并且多个客
高并发下的分布式缓存 | Write-Through缓存模式非科班大厂码农（同名公众号）分布式缓存
缓存系列文章链接如下：高并发下的分布式缓存|缓存系统稳定性设计高并发下的分布式缓存|设计和实现LRU缓存高并发下的分布式缓存|设计和实现LFU缓存高并发下的分布式缓存|Cache-Aside缓存模式高并发下的分布式缓存|Read-Through缓存模式Write-Through模式的缓存操作Write-Through模式的思路与Read-Through模式类似，但有一个关键的区别：在这里，缓存负责
PostgreSQL 性能优化全方位指南：深度提升数据库效率 Koishi_TvT 数据库 postgresql 性能优化 github
PostgreSQL性能优化全方位指南：深度提升数据库效率别忘了请点个赞+收藏+关注支持一下博主喵！！！在现代互联网应用中，数据库性能优化是系统优化中至关重要的一环，尤其对于数据密集型和高并发的应用而言，PostgreSQL（以下简称PG）凭借其丰富的特性和强大的功能，成为很多企业的首选。然而，随着数据规模的扩展和查询复杂度的提升，PostgreSQL的性能问题逐渐显现。本文将详细介绍Postgr
Java基础 --- 多线程&JUC，以及一些常用的设计模式总结 lzhlizihang java 设计模式
文章目录一、多线程1、线程和进程的区别2、创建多线程的四种方式3、集合中的线程安全二、设计模式1、单例模式2、装饰者模式（IO流缓冲流）3、适配器模式4、模板模式一、多线程1、线程和进程的区别进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位，一个进程可以运行多个线程多进程：操作系统中同时运行的多个程序多线程：在同一个进程中同时运行的多个任务2、创建多线程的四种方式Runna
Redis-1 缓存穿透、缓存击穿、缓存雪崩七折困面试缓存 redis 数据库
缓存穿透一.数据查询的流程程序根据请求查询数据时，会先到redis中查询，如果redis中查到了目标数据，则直接返回；如果redis中没有目标数据，则到mysql中查找，找到目标数据后返回，同时将该数据写入到redis中。二.什么是缓存穿透？查询一个数据库中不存在的数据，由于数据库中没有该数据，因此也不会写入到redis中，导致每次请求该数据都要查询数据库。大量针对该数据的高并发请求可能会导致数据
消息总线RabbitMQ Crystalqy 微服务消息队列 rabbitmq
RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件，也称为面向消息的中间件，是一个在AMQP基础上完整的，可复用的企业消息系统。它可以用于大型软件系统各个模块之间的高效通信，支持高并发，支持可扩展。AMQP，即AdvancedMessageQueuingProtocol,一个提供统一消息服务的应用层标准高级消息队列协议,是应用层协议的一个开放标准,为面向消息的中间件设计，它定义
Redis 多线程模型详解 CopyLower Java 学习 Redis redis 数据库缓存
引言Redis作为一款高性能的内存数据库，以其简单的设计和单线程模型广受欢迎。然而，随着用户需求和数据规模的增长，单线程的架构逐渐成为Redis性能的瓶颈。近年来，Redis开始引入部分多线程机制，以提高并发性能，特别是在处理网络I/O和数据持久化时。因此，本文将详细解析Redis的多线程模型，重点介绍Redis如何处理并发、单线程与多线程的结合方式以及多线程机制带来的性能提升。第一部分：Redi
关于大型网站技术演进的思考 weixin_30270889
网站静态化处理--总述（1）在存储瓶颈的开篇我提到像hao123这样的导航网站只要它部署的web服务器数量足够，它可以承载超大规模的并发访问量，如果是一个动态的网站，特别是使用到了数据库的网站是很难做到通过增加web服务器数量的方式来有效的增加网站并发访问能力的。但是现实情况是像淘宝、京东这样的大型动态网站在承担高并发的情况下任然能保证快速的响应，这其中有什么样的技术手段可以达到动态网站支撑高并发
多线程编程之卫生间周凡杨 java 并发卫生间线程厕所
如大家所知，火车上车厢的卫生间很小，每次只能容纳一个人，一个车厢只有一个卫生间，这个卫生间会被多个人同时使用，在实际使用时，当一个人进入卫生间时则会把卫生间锁上，等出来时打开门，下一个人进去把门锁上，如果有一个人在卫生间内部则别人的人发现门是锁的则只能在外面等待。问题分析：首先问题中有两个实体，一个是人，一个是厕所，所以设计程序时就可以设计两个类。人是多数的，厕所只有一个（暂且模拟的是一个车厢）。
How to Install GUI to Centos Minimal sunjing linux Install Desktop GUI
http://www.namhuy.net/475/how-to-install-gui-to-centos-minimal.html I have centos 6.3 minimal running as web server. I’m looking to install gui to my server to vnc to my server. You can insta
Shell 函数 daizj shell 函数
Shell 函数 linux shell 可以用户定义函数，然后在shell脚本中可以随便调用。 shell中函数的定义格式如下： [function] funname [()]{ action; [return int;] } 说明： 1、可以带function fun() 定义，也可以直接fun() 定义,不带任何参数。 2、参数返回
Linux服务器新手操作之一周凡杨 Linux 简单操作
1.whoami 当一个用户登录Linux系统之后，也许他想知道自己是发哪个用户登录的。此时可以使用whoami命令。 [ecuser@HA5-DZ05 ~]$ whoami e
浅谈Socket通信（一）朱辉辉33 socket
在java中ServerSocket用于服务器端，用来监听端口。通过服务器监听，客户端发送请求，双方建立链接后才能通信。当服务器和客户端建立链接后，两边都会产生一个Socket实例，我们可以通过操作Socket来建立通信。首先我建立一个ServerSocket对象。当然要导入java.net.ServerSocket包 ServerSock
关于框架的简单认识西蜀石兰框架
入职两个月多，依然是一个不会写代码的小白，每天的工作就是看代码，写wiki。前端接触CSS、HTML、JS等语言，一直在用的CS模型，自然免不了数据库的链接及使用，真心涉及框架，项目中用到的BootStrap算一个吧，哦，JQuery只能算半个框架吧，我更觉得它是另外一种语言。后台一直是纯Java代码，涉及的框架是Quzrtz和log4j。都说学前端的要知道三大框架，目前node.
You have an error in your SQL syntax; check the manual that corresponds to your 林鹤霄
You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'option,changed_ids ) values('0ac91f167f754c8cbac00e9e3dc372
MySQL5.6的my.ini配置 aigo mysql
注意：以下配置的服务器硬件是：8核16G内存 [client] port=3306 [mysql] default-character-set=utf8 [mysqld] port=3306 basedir=D:/mysql-5.6.21-win
mysql 全文模糊查找便捷解决方案 alxw4616 mysql
mysql 全文模糊查找便捷解决方案 2013/6/14 by 半仙 [email protected] 目的: 项目需求实现模糊查找. 原则: 查询不能超过 1秒. 问题: 目标表中有超过1千万条记录. 使用like '%str%' 进行模糊查询无法达到性能需求. 解决方案: 使用mysql全文索引. 1.全文索引 : MySQL支持全文索引和搜索功能。MySQL中的全文索
自定义数据结构链表(单项 ,双向,环形) 百合不是茶单项链表双向链表
链表与动态数组的实现方式差不多, 数组适合快速删除某个元素链表则可以快速的保存数组并且可以是不连续的单项链表;数据从第一个指向最后一个实现代码: //定义动态链表 clas
threadLocal实例 bijian1013 java thread java多线程 threadLocal
实例1： package com.bijian.thread; public class MyThread extends Thread { private static ThreadLocal tl = new ThreadLocal() { protected synchronized Object initialValue() { return new Inte
activemq安全设置—设置admin的用户名和密码 bijian1013 java activemq
ActiveMQ使用的是jetty服务器, 打开conf/jetty.xml文件，找到 <bean id="adminSecurityConstraint" class="org.eclipse.jetty.util.security.Constraint"> <p
【Java范型一】Java范型详解之范型集合和自定义范型类 bit1129 java
本文详细介绍Java的范型，写一篇关于范型的博客原因有两个，前几天要写个范型方法(返回值根据传入的类型而定)，竟然想了半天，最后还是从网上找了个范型方法的写法；再者，前一段时间在看Gson, Gson这个JSON包的精华就在于对范型的优雅简单的处理，看它的源代码就比较迷糊，只其然不知其所以然。所以，还是花点时间系统的整理总结下范型吧。范型内容范型集合类范型类
【HBase十二】HFile存储的是一个列族的数据 bit1129 hbase
在HBase中，每个HFile存储的是一个表中一个列族的数据，也就是说，当一个表中有多个列簇时，针对每个列簇插入数据，最后产生的数据是多个HFile，每个对应一个列族，通过如下操作验证 1. 建立一个有两个列族的表 create 'members','colfam1','colfam2' 2. 在members表中的colfam1中插入50*5
Nginx 官方一个配置实例 ronin47 nginx 配置实例
user www www; worker_processes 5; error_log logs/error.log; pid logs/nginx.pid; worker_rlimit_nofile 8192; events { worker_connections 4096;} http { include conf/mim
java-15.输入一颗二元查找树，将该树转换为它的镜像，即在转换后的二元查找树中，左子树的结点都大于右子树的结点。用递归和循环 bylijinnan java
//use recursion public static void mirrorHelp1(Node node){ if(node==null)return; swapChild(node); mirrorHelp1(node.getLeft()); mirrorHelp1(node.getRight()); } //use no recursion bu
返回null还是empty bylijinnan java apache spring 编程
第一个问题，函数是应当返回null还是长度为0的数组（或集合）？第二个问题，函数输入参数不当时，是异常还是返回null？先看第一个问题有两个约定我觉得应当遵守： 1.返回零长度的数组或集合而不是null（详见《Effective Java》）理由就是，如果返回empty，就可以少了很多not-null判断： List<Person> list
[科技与项目]工作流厂商的战略机遇期 comsci 工作流
在新的战略平衡形成之前，这里有一个短暂的战略机遇期，只有大概最短6年，最长14年的时间，这段时间就好像我们森林里面的小动物，在秋天中，必须抓紧一切时间存储坚果一样，否则无法熬过漫长的冬季。。。。在微软，甲骨文，谷歌，IBM,SONY
过度设计-举例 cuityang 过度设计
过度设计，需要更多设计时间和测试成本，如无必要，还是尽量简洁一些好。未来的事情，比如访问量，比如数据库的容量，比如是否需要改成分布式都是无法预料的再举一个例子，对闰年的判断逻辑：　　1、 if($Year%4==0) return True; else return Fasle; 　　2、if ( ($Year%4==0 &am
java进阶，《Java性能优化权威指南》试读 darkblue086 java性能优化
记得当年随意读了微软出版社的.NET 2.0应用程序调试，才发现调试器如此强大，应用程序开发调试其实真的简单了很多，不仅仅是因为里面介绍了很多调试器工具的使用，更是因为里面寻找问题并重现问题的思想让我震撼，时隔多年，Java已经如日中天，成为许多大型企业应用的首选，而今天，这本《Java性能优化权威指南》让我再次找到了这种感觉，从不经意的开发过程让我刮目相看，原来性能调优不是简单地看看热点在哪里，
网络学习笔记初识OSI七层模型与TCP协议 dcj3sjt126com 学习笔记
协议：在计算机网络中通信各方面所达成的、共同遵守和执行的一系列约定　　计算机网络的体系结构：计算机网络的层次结构和各层协议的集合。　　两类服务：　　面向连接的服务通信双方在通信之前先建立某种状态，并在通信过程中维持这种状态的变化，同时为服务对象预先分配一定的资源。这种服务叫做面向连接的服务。　　面向无连接的服务通信双方在通信前后不建立和维持状态，不为服务对象
mac中用命令行运行mysql dcj3sjt126com mysql linux mac
参考这篇博客：http://www.cnblogs.com/macro-cheng/archive/2011/10/25/mysql-001.html 感觉workbench不好用（有点先入为主了）。 1，安装mysql 在mysql的官方网站下载 mysql 5.5.23 http://www.mysql.com/downloads/mysql/，根据我的机器的配置情况选择了64
MongDB查询（1）——基本查询[五] eksliang mongodb mongodb 查询 mongodb find
MongDB查询转载请出自出处：http://eksliang.iteye.com/blog/2174452 一、find简介 MongoDB中使用find来进行查询。 API:如下 function ( query , fields , limit , skip, batchSize, options ){.....} 参数含义： query:查询参数 fie
base64，加密解密经融加密，对接 y806839048 经融加密对接
String data0 = new String(Base64.encode(bo.getPaymentResult().getBytes(("GBK")))); String data1 = new String(Base64.decode(data0.toCharArray()),"GBK"); // 注意编码格式，注意用于加密，解密的要是同
JavaWeb之JSP概述 ihuning javaweb
什么是JSP？为什么使用JSP？ JSP表示Java Server Page，即嵌有Java代码的HTML页面。使用JSP是因为在HTML中嵌入Java代码比在Java代码中拼接字符串更容易、更方便和更高效。 JSP起源在很多动态网页中，绝大部分内容都是固定不变的，只有局部内容需要动态产生和改变。如果使用Servl
apple watch 指南啸笑天 apple
1. 文档 WatchKit Programming Guide（中译在线版 By @CocoaChina）译文译者原文概览 - 开始为 Apple Watch 进行开发 @星夜暮晨 Overview - Developing for Apple Watch 概览 - 配置 Xcode 项目 - Overview - Configuring Yo
java经典的基础题目 macroli java 编程
1.列举出 10个JAVA语言的优势 a:免费，开源，跨平台(平台独立性)，简单易用，功能完善，面向对象，健壮性，多线程，结构中立，企业应用的成熟平台, 无线应用 2.列举出JAVA中10个面向对象编程的术语 a:包，类，接口，对象，属性，方法，构造器，继承，封装，多态，抽象，范型 3.列举出JAVA中6个比较常用的包 Java.lang;java.util;java.io;java.sql;ja
你所不知道神奇的js replace正则表达式 qiaolevip 每天进步一点点学习永无止境纵观千象 regex
var v = 'C9CFBAA3CAD0'; console.log(v); var arr = v.split(''); for (var i = 0; i < arr.length; i ++) { if (i % 2 == 0) arr[i] = '%' + arr[i]; } console.log(arr.join('')); console.log(v.r
[一起学Hive]之十五-分析Hive表和分区的统计信息(Statistics) superlxw1234 hive hive分析表 hive统计信息 hive Statistics
关键字：Hive统计信息、分析Hive表、Hive Statistics 类似于Oracle的分析表，Hive中也提供了分析表和分区的功能，通过自动和手动分析Hive表，将Hive表的一些统计信息存储到元数据中。表和分区的统计信息主要包括：行数、文件数、原始数据大小、所占存储大小、最后一次操作时间等； 14.1 新表的统计信息对于一个新创建
Spring Boot 1.2.5 发布 wiselyman spring boot
Spring Boot 1.2.5已在7月2日发布，现在可以从spring的maven库和maven中心库下载。这个版本是一个维护的发布版，主要是一些修复以及将Spring的依赖提升至4.1.7(包含重要的安全修复)。官方建议所有的Spring Boot用户升级这个版本。项目首页 | 源