多线程进阶

  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++  
    private native void start0();

并发、并行

并发：多线程操作同一个资源，CPU单核，模拟出多条线程，快速交替。

并行：CPU多核，多个线程同时执行；线程池。

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

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

线程状态

  public enum State {
        // 新生   
        NEW,
         
        //运行
        RUNNABLE,

        //阻塞
        BLOCKED,

        //等待
        WAITING,

        //超时等待   
        TIMED_WAITING,

        //终止   
        TERMINATED;
    }

wait、sleep的区别

来自不同的类，wait来自Object类，sleep来自Thread类
在调用wait方法后，锁会被释放，但是调用sleep方法，锁并不会被释放
使用范围不同：wait必须在同步代码块中使用，sleep可以在任何地方使用

Lock锁

传统的synchronized锁

package com.zjb.juc;

public class SaleTicketSynchronizedDemo {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

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

class Ticket{

    private static int numbers = 30;

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

    }

}

synchronized的本质：队列，锁。

Lock锁

lock锁通过jdk帮助文档，我们可以得知Lock是一个接口，它有三个接口

ReentrantLock：可重入锁（常用）
ReentrantReadWriteLock.ReadLock：读锁
ReentrantReadWriteLock.WriteLock：写锁

通过查看ReentrantLock源码，可以看到在这里使用公平锁、非公平锁

公平锁：十分公平，先来后到

非公平锁：十分不公平，可以插队（默认）

package com.zjb.juc;

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

public class SaleTicketLockDemo {
    public static void main(String[] args) {
        Ticket2 ticket = new Ticket2();

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

class Ticket2{

    private static int numbers = 30;

    Lock lock = new ReentrantLock();

    public void sale(){
        //加锁
        lock.lock();
        try{
            //业务代码
            if(numbers > 0){
                System.out.println(Thread.currentThread().getName()+"卖出第"+(numbers--)+"张票,剩余"+numbers+"票");
            }
        }finally {
            //解锁
            lock.unlock();
        }
    }

}

synchronized和lock的区别

synchronized是内置的Java关键字，Lock是一个java类
synchronized无法判断获取锁的状态，Lock可以判断是否获取到了锁
synchronized会自动释放锁，lock必须要手动释放锁。如果不释放锁，会发生死锁
synchronized 线程1（获得锁之后，假设发生了阻塞），线程2就会一直在等待。而Lock锁就不一定会一直等待
synchronized可重入锁，不可以中断，非公平，Lock，可重入锁，可以判断锁，公平非公平可以自己设置（默认非公平）
synchronized适合锁少量的代码同步问题，Lock适合锁大量的同步代码

传统（synchronized）生产者、消费者问题

package com.zjb.juc.pc;

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

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

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

    }

}

class Data{
    private static int number = 0;

    public synchronized void decr() throws Exception{
        if(number == 0){
            this.wait();
        }
        number --;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll();
    }
    public synchronized void incr() throws Exception{
        if(number != 0){
            this.wait();
        }
        number ++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll();
    }

}

结果

那我们在去添加2个线程

package com.zjb.juc.pc;

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

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

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

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

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

}

class Data{
    private static int number = 0;

    public synchronized void decr() throws Exception{
        if(number == 0){
            this.wait();
        }
        number --;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll();
    }
    public synchronized void incr() throws Exception{
        if(number != 0){
            this.wait();
        }
        number ++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll();
    }

}

结果

我们发现并不是我们想要的结果，这是什么原因呢？应该怎么去解决呢？

在jdk文档中的wait方法中可以看到，是因为if判断导致的虚假唤醒

解决方案：把if判断改为while判断

package com.zjb.juc.pc;

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

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

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

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

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

}

class Data{
    private static int number = 0;

    public synchronized void decr() throws Exception{
        while(number == 0){
            this.wait();
        }
        number --;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll();
    }
    public synchronized void incr() throws Exception{
        while(number != 0){
            this.wait();
        }
        number ++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll();
    }

}

Lock生产者、消费者问题

package com.zjb.juc.pc;

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

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

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

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

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

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

}

class LockData{
    private static int number = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    public void decr() throws Exception{
        lock.lock();
        try {
            while(number == 0){
                //等待
                condition.await();
            }
            number --;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //唤醒
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public  void incr() throws Exception{
        lock.lock();
        try {
            while(number != 0){
                condition.await();
            }
            number ++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


    }

}

Condition实现精准通知和唤醒

package com.zjb.juc.pc;

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

/**
 * 启动两个线程，输出AABAABAABAABAAB
 */

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

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

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

class ConditionData{
    private int number = 1;

    private Lock lock = new ReentrantLock();
    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();
    public void printA(){
        lock.lock();
        try {
            while(number == 3){
                conditionA.await();
            }
            number ++;
            System.out.print(Thread.currentThread().getName());
            conditionB.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB(){
        lock.lock();
        try {
            while(number != 3){
                conditionB.await();
            }
            number = 1;
            System.out.print(Thread.currentThread().getName());
            conditionA.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

锁的8个问题

问题一、标准情况下，两个线程打印，哪个线程先执行？

package com.zjb.juc.lock8;


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

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

}

class Phone{
    public synchronized void sendSms(){
        System.out.println("发短信");
    }

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

结果

通过结果我们发现，总是A线程先执行，B线程再执行。

问题二、A线程延迟N秒，两个线程打印，哪个线程先执行？

package com.zjb.juc.lock8;


import java.util.concurrent.TimeUnit;

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

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

}

class Phone{
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果

通过结果，我们发现还是A线程先执行，B线程再执行。

结论：因为synchronized锁的对象是方法的调用者，A线程，B线程用的是同一个锁，谁先拿到锁谁就先执行。

问题三、一个普通方法，A线程延迟N秒，A线程调用同步方法，B线程调用普通方法，两个线程打印，哪个线程先执行？

package com.zjb.juc.lock8;


import java.util.concurrent.TimeUnit;

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

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

}

class Phone{
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果

通过结果发现，B线程先执行，A线程再执行。是因为call方法是普通方法，不受锁的影响。

问题四、创建两个对象，A线程延迟N秒，两个线程打印，哪个线程先执行？

package com.zjb.juc.lock8;


import java.util.concurrent.TimeUnit;

public class Lock8 {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

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

}

class Phone{
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果

通过结果发现，B线程先执行，A线程再执行。是因为synchronized锁的对象是方法的调用者，这里是两个对象，两个调用者，两把锁。

问题五、添加静态同步方法，A线程延迟N秒，两个线程打印，哪个线程先执行？

package com.zjb.juc.lock8;


import java.util.concurrent.TimeUnit;

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

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

}

class Phone{
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果

通过结果发现，A线程先执行，B线程再执行。因为static修饰的方法是静态方法，类一加载就有了，锁的是Class。

问题六、添加静态同步方法，创建两个对象，A线程延迟N秒，两个线程打印，哪个线程先执行？

package com.zjb.juc.lock8;


import java.util.concurrent.TimeUnit;

public class Lock8 {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

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

}

class Phone{
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果

通过结果发现，A线程先执行，B线程再执行。因为static修饰的同步方法锁的是Class，两个对象的Class类模板只有一个。

问题七、一个静态同步方法，一个普通同步方法，一个对象，A线程延迟N秒，两个线程打印，哪个线程先执行？

package com.zjb.juc.lock8;


import java.util.concurrent.TimeUnit;

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

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

}

class Phone{
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果

通过结果发现，B线程先执行，A线程再执行。

问题八、一个静态同步方法，一个普通同步方法，两个对象，A线程延迟N秒，两个线程打印，哪个线程先执行？

package com.zjb.juc.lock8;


import java.util.concurrent.TimeUnit;

public class Lock8 {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

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

}

class Phone{
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果

通过结果发现，B线程先执行，A线程再执行。

结论：因为static修饰的同步方法锁的是Class，普通同步方法锁的是调用者，它们用的不是同一把锁。

集合类不安全

List

现在我们向一个List集合中添加一些元素，正常情况下，我们的代码如下

package com.zjb.juc.unsafe;

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

public class ListTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

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

但是在我们运行的时候，会报java.util.ConcurrentModificationException这样一个错误。

那我们应该怎么解决呢？

1、修改ArrayList为Vector

package com.zjb.juc.unsafe;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.Vector;

public class ListTest {
    public static void main(String[] args) {
        List<String> list = new Vector<>();

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

我们看下Vector和ArrayList的add方法的源码

ArrayList

Vector

发现是因为加了synchronized关键字

2、把ArrayList变成安全的

package com.zjb.juc.unsafe;

import java.util.*;

public class ListTest {
    public static void main(String[] args) {
        List<String> list = Collections.synchronizedList(new ArrayList<>());

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

3、使用CopyOnWriteArrayList

CopyOnWrite：写入时复制，计算机程序设计领域的一种优化策略。

多线程调用的时候，读取的时候是没问题的，写入的时候，会发生数据覆盖问题。使用

CopyOnWrite在写入的时候避免覆盖，造成数据问题。

package com.zjb.juc.unsafe;

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

public class ListTest {
    public static void main(String[] args) {
        List<String> list = new CopyOnWriteArrayList<>();

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

CopyOnWriteArrayList 比 Vector 好在哪里

我们先看下源码，

CopyOnWriteArrayList

 public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

Vector

  public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

Vector使用synchronized关键字，效率比较低。

Set

同理可证，正常情况下，依然会报java.util.ConcurrentModificationException这样的错误。那我们怎么解决呢？

1、把HashSet变成安全的

package com.zjb.juc.unsafe;

import java.util.*;

public class SetTest {
    public static void main(String[] args) {
        Set<String> set = Collections.synchronizedSet(new HashSet<>());

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

2、使用CopyOnWriteArraySet

package com.zjb.juc.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArraySet;

public class SetTest {
    public static void main(String[] args) {
        Set<String> set = new CopyOnWriteArraySet<>();

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

HashSet的底层是什么？查看源码可知，hashSet的本质其实就是一个map

  public HashSet() {
        map = new HashMap<>();
  }

再看下它的add方法

  public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

HashMap

1、把HashMap变成安全的

package com.zjb.juc.unsafe;

import java.util.*;

public class MapTest {
    public static void main(String[] args) {
        Map<String,String> map = Collections.synchronizedMap(new HashMap<>());

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

2、使用ConcurrentHashMap

package com.zjb.juc.unsafe;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class MapTest {
    public static void main(String[] args) {
        Map<String,String> map = new ConcurrentHashMap<>();

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

Callable

callable可以用返回值，可以抛出异常，使用call方法。

package com.zjb.juc.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 {

        FutureTask futureTask = new FutureTask(new MyThread());
        new Thread(futureTask).start();
        //获取返回值
        System.out.println(futureTask.get());
    }
}

class MyThread implements Callable<Boolean>{

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

细节：

1. 有缓存

2. 返回结果可能需要等待，会阻塞。

常用的辅助类

CountDownLatch（减法计数器）

package com.zjb.juc;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 1; i <=6 ; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"执行完毕");
                countDownLatch.countDown(); //数量减1
            },String.valueOf(i)).start();
        }
        countDownLatch.await();
        System.out.println("finished");
    }
}

countDown:数量减1

await：等待计数器归零，然后再向下执行。

CyclicBarrier （加法计数器）

package com.zjb.juc;

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

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("执行完毕");
        });

        for (int i = 1; i <=7 ; i++) {
            new Thread(()->{
                try {
                    System.out.println(Thread.currentThread().getName()+"执行了");
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

Semaphore（信号量）

package com.zjb.juc;

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

public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);

        for (int i = 1; i <=6 ; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire(); //得到
                    System.out.println(Thread.currentThread().getName()+"得到了车位");
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println(Thread.currentThread().getName()+"离开了车位");
                    semaphore.release(); //释放
                }
            },String.valueOf(i)).start();
        }
    }
}

semaphore.acquire()：获得，假设如果已经满了，等待，等待被释放为止。

semaphore.release()：释放，会将当前的信号量释放，然后唤醒等待的线程。

作用：多个共享资源互斥的使用。并发限流，控制最大的线程数。

读写锁（ReadWriteLock）

读可以被多线程同时去读，写的时候只能有一个线程去写。也叫独占锁（写锁）、共享锁（读锁）。

作用：更加细粒度的控制锁。

package com.zjb.juc;

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

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

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

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

class MyCacheLock {

    private volatile Map<String,Object> map = new HashMap<>();
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public void put(String key,Object value){
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"开始写入"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写入完成"+key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }

    public void get(String key){
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"开始读取"+key);
            map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取完成"+key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

阻塞对列（BlockingQueue）

什么情况下使用？

多线程并发处理，线程池。

四组API

方式	抛出异常	有返回值，不抛出异常	阻塞一直等待	超时等待
添加	add	offer	put	offer
移除	remove	poll	take	poll
检测队首元素	element	peek	-	-

 /**
     * 抛出异常
     */
    public static void test1(){
        ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        //添加
        System.out.println(arrayBlockingQueue.add("a"));
        System.out.println(arrayBlockingQueue.add("b"));
        System.out.println(arrayBlockingQueue.add("c"));

        //java.lang.IllegalStateException: Queue full
        //arrayBlockingQueue.add("d");

        //检测队首元素
        System.out.println(arrayBlockingQueue.element());

        System.out.println("======================");
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());
        //java.util.NoSuchElementException
        //arrayBlockingQueue.remove();
    }

/**
     * 有返回值，不抛出异常
     */
    public static void test2(){
        ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        //添加
        System.out.println(arrayBlockingQueue.offer("a"));
        System.out.println(arrayBlockingQueue.offer("b"));
        System.out.println(arrayBlockingQueue.offer("c"));


        System.out.println(arrayBlockingQueue.offer("d"));

        //检测队首元素
        System.out.println(arrayBlockingQueue.peek());

        System.out.println("======================");
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());

        System.out.println(arrayBlockingQueue.poll());
    }

/**
     * 阻塞一直等待
     */
    public static void test3() throws InterruptedException {
        ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        //添加
        arrayBlockingQueue.put("a");
        arrayBlockingQueue.put("b");
        arrayBlockingQueue.put("c");

       // arrayBlockingQueue.put("d");

        //移除
        arrayBlockingQueue.take();
        arrayBlockingQueue.take();
        arrayBlockingQueue.take();
        //arrayBlockingQueue.take();

    }

/**
     * 超时等待
     */
    public static void test4() throws InterruptedException {
        ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        //添加
        System.out.println(arrayBlockingQueue.offer("a"));
        System.out.println(arrayBlockingQueue.offer("b"));
        System.out.println(arrayBlockingQueue.offer("c"));


        System.out.println(arrayBlockingQueue.offer("d",2, TimeUnit.SECONDS));


        System.out.println("======================");

        //移除
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());

        System.out.println(arrayBlockingQueue.poll(2,TimeUnit.SECONDS));
    }

同步队列（SynchronousQueue）

没有容量，放入一个元素，必须等待取出来之后，才能再往里面放入下一个元素。

package com.zjb.juc.queue;

import java.util.concurrent.SynchronousQueue;

public class SynchronousQueueDemo {
    public static void main(String[] args) {
        SynchronousQueue<String> synchronousQueue = new SynchronousQueue<>();

        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"put 1");
                synchronousQueue.put("1");
                System.out.println(Thread.currentThread().getName()+"put 2");
                synchronousQueue.put("2");
                System.out.println(Thread.currentThread().getName()+"put 3");
                synchronousQueue.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"==>"+synchronousQueue.take());
                System.out.println(Thread.currentThread().getName()+"==>"+synchronousQueue.take());
                System.out.println(Thread.currentThread().getName()+"==>"+synchronousQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}

线程池

线程池的好处：线程复用，可以控制最大并发数，管理线程

降低资源的消耗
提高响应的速度
方便管理

三大方法

newSingleThreadExecutor：创建一个单一线程池

newFixedThreadPool：创建一个固定大小的线程池

newCachedThreadPool：创建一个可伸缩的线程池

package com.zjb.juc.pool;

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

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

        for (int i = 1; i <=10 ; i++) {
            threadPool.execute(()->{
                System.out.println(Thread.currentThread().getName()+"ok");
            });
        }
    }
}

7大参数

源码分析

 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,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
  }

 // 发现本质都是通过new 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.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

corePoolSize：核心线程池大小

maximumPoolSize：最大核心线程池大小

keepAliveTime：超时了没有人调用就释放

unit：超时单位

workQueue：阻塞队列

threadFactory：线程工厂，用来创建线程，一般不需要改动

handler：拒绝策略

4种拒绝策略

AbortPolicy：如果线程池满了，还有线程进来，就不再处理，直接抛出异常

CallerRunsPolicy：哪里来的去哪里，也就是交给了主线程去处理。

DiscardOldestPolicy：如果线程池满了，尝试去和最早的竞争，如果竞争失败，丢掉任务，不会抛出异常

DiscardPolicy：如果线程池满了，还有线程进来，丢掉任务，不会抛出异常

自定义线程池

package com.zjb.juc.pool;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class DiyThreadPool {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2,
                5,
                2,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());


        for (int i = 1; i <= 9 ; i++) {
            threadPool.execute(()->{
                System.out.println(Thread.currentThread().getName()+"ok");
            });
        }
    }
}

最大线程数如何定义

1.CPU密集型：服务器是几核的最大线程数就是几，可以保证CPU效率最高

//获取CPU核数
Runtime.getRuntime().availableProcessors()

2.IO密集型：判断程序中十分耗IO的线程是多少，一般情况下会设置为它的2倍。

四大函数式接口

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

好处：简化编程模型。

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

Function（函数型接口）

有一个输出参数，一个返回参数

源码

示例

package com.zjb.juc.function;

import java.util.function.Function;

public class FunctionDemo {
    public static void main(String[] args) {
       /* Function<String, String> function = new Function<String, String>() {
            @Override
            public String apply(String str) {
                return str;
            }
        };*/
        Function<String, String> function = (str) ->{return str;};
        System.out.println(function.apply("asc"));
    }
}

Predicate（断定型接口）

只有一个输入参数，返回值只能是boolean

源码

示例

package com.zjb.juc.function;

import java.util.function.Predicate;

public class PredicateDemo {
    public static void main(String[] args) {
       /* Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean test(String str) {
                return str.isEmpty();
            }
        };*/
        Predicate<String> predicate = (str) ->{return str.isEmpty();};
        System.out.println(predicate.test("asc"));
    }
}

Consumer（消费型接口）

只有一个输入参数，没有返回值

源码

示例

package com.zjb.juc.function;

import java.util.function.Consumer;

public class ConsumerDemo {
    public static void main(String[] args) {
       /* Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String str) {
                System.out.println(str);
            }
        };*/
        Consumer<String> consumer = (str) ->{ System.out.println(str); };
        consumer.accept("asc");

    }
}

Supplier（供给型接口）

只有一个返回值，没有输入参数

源码

示例

package com.zjb.juc.function;

import java.util.function.Supplier;

public class SupplierDemo {
    public static void main(String[] args) {
        /*Supplier<String> supplier = new Supplier<String>() {
            @Override
            public String get() {
                return "123";
            }
        };*/
        Supplier<String> supplier = () ->{return "123";};
        System.out.println(supplier.get());
    }
}

Stream流式计算

package com.zjb.juc.stream;

import java.util.Arrays;
import java.util.List;

/**
 * 现在有5个用户，筛选
 * 1、ID必须是偶数
 * 2、年龄必须大于23岁
 * 3、用户名转为大写字母
 * 4、用户名字母倒序
 * 5、只输出一个用户
 */
public class StreamDemo {
    public static void main(String[] args) {
        User u1 = new User(1,"a",21);
        User u2 = new User(2,"b",22);
        User u3 = new User(3,"c",23);
        User u4 = new User(4,"d",24);
        User u5 = new User(5,"e",25);
        List<User> list = Arrays.asList(u1,u2,u3,u4,u5);
        list.stream()
                .filter(u->u.getId()%2==0)
                .filter(u->u.getAge()>23)
                .map(u->u.getName().toUpperCase())
                .sorted((o1,o2) ->{return o2.compareTo(o1);})
                .limit(1)
                .forEach(System.out::println);

    }
}

ForkJoin

ForkJoin在jdk1.7之后才出现，并行执行任务，在大数据量时，提高效率。

之所以可以提高效率的原因是因为ForkJoin工作窃取。里面维护的是双端队列。

package com.zjb.juc.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 += i;
            }
            return sum;
        }else{
            long middle = (start + end) / 2;
            ForkJoinDemo task1 = new ForkJoinDemo(start,middle);
            task1.fork();
            ForkJoinDemo task2 = new ForkJoinDemo(middle+1,end);
            task2.fork();
            return task1.join() + task2.join();
        }
    }
}

package com.zjb.juc.forkjoin;

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

public class ForkJoinTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //test1(); //sum=499999999500000000耗时:271
        test2(); //sum=499934463999828390耗时:162
        //test3();//sum=500000000500000000耗时:155
    }

    /**
     * 普通计算
     */
    public static void test1(){
        long start = System.currentTimeMillis();
        long sum = 0L;
        for (long i = 0; i < 10_0000_0000 ;i++) {
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+ "耗时:"+(end-start));
    }

    /**
     * ForkJoin
     * @throws ExecutionException
     * @throws InterruptedException
     */
    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> forkJoinDemo = new ForkJoinDemo(0L, 10_0000_0000L);
        ForkJoinTask<Long> submit = forkJoinPool.submit(forkJoinDemo);
        Long sum = submit.get();
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+ "耗时:"+(end-start));
    }

    /**
     * stream并行流
     */
    public static void test3(){
        long start = System.currentTimeMillis();
        long sum = LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0, Long::sum);
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+ "耗时:"+(end-start));
    }
}

异步回调

无返回值的异步回调：runAsync

package com.zjb.juc.future;

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

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

        /**
         * 没有返回值异步回调：runAsync
         */
        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"runAsync");
        });

        System.out.println("11111");
        //获取执行结果
        System.out.println(voidCompletableFuture.get());
    }
}

有返回值异步回调：supplyAsync

package com.zjb.juc.future;

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

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

        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "supplyAsync");
            return 200;
        });

        System.out.println(completableFuture.whenComplete((t, u) -> {
            System.out.println("t=>" + t); //正常的返回结果
            System.out.println("u=>" + u); //错误信息
        }).exceptionally((e) -> {
            System.out.println(e.getMessage());
            return 500; //设置错误的返回结果
        }).get()); 

    }
}

JMM

什么是JMM

内存模型可以理解为在特定的操作协议下，对特定的内存或者高速缓存进行读写访问的过程抽象描述，不同架构下的物理机拥有不一样的内存模型，Java虚拟机是一个实现了跨平台的虚拟系统，因此它也有自己的内存模型，即Java内存模型。

关于JMM的一些同步的约定

1.线程解锁前，必须把共享变量立刻刷回到主内存。

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

3.加锁、解锁是同一把锁。

线程的内存

工作内存
主内存

工作原理

关于主内存与工作内存之间的交互协议，即一个变量如何从主内存拷贝到工作内存。如何从工作内存同步到主内存中的实现细节。java内存模型定义了8种操作来完成。这8种操作每一种都是原子操作。8种操作如下：

lock(锁定)：作用于主内存，它把一个变量标记为一条线程独占状态；
read(读取)：作用于主内存，它把变量值从主内存传送到线程的工作内存中，以便随后的load动作使用；
load(载入)：作用于工作内存，它把read操作的值放入工作内存中的变量副本中；
use(使用)：作用于工作内存，它把工作内存中的值传递给执行引擎，每当虚拟机遇到一个需要使用这个变量的指令时候，将会执行这个动作；
assign(赋值)：作用于工作内存，它把从执行引擎获取的值赋值给工作内存中的变量，每当虚拟机遇到一个给变量赋值的指令时候，执行该操作；
store(存储)：作用于工作内存，它把工作内存中的一个变量传送给主内存中，以备随后的write操作使用；
write(写入)：作用于主内存，它把store传送值放到主内存中的变量中。
unlock(解锁)：作用于主内存，它将一个处于锁定状态的变量释放出来，释放后的变量才能够被其他线程锁定；

Java内存模型还规定了执行上述8种基本操作时必须满足如下规则:

（1）不允许read和load、store和write操作之一单独出现（即不允许一个变量从主存读取了但是工作内存不接受，或者从工作内存发起会写了但是主存不接受的情况），以上两个操作必须按顺序执行，但没有保证必须连续执行，也就是说，read与load之间、store与write之间是可插入其他指令的。

（2）不允许一个线程丢弃它的最近的assign操作，即变量在工作内存中改变了之后必须把该变化同步回主内存。

（3）不允许一个线程无原因地（没有发生过任何assign操作）把数据从线程的工作内存同步回主内存中。

（4）一个新的变量只能从主内存中“诞生”，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量，换句话说就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。

（5）一个变量在同一个时刻只允许一条线程对其执行lock操作，但lock操作可以被同一个条线程重复执行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解锁。

（6）如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前，需要重新执行load或assign操作初始化变量的值。

（7）如果一个变量实现没有被lock操作锁定，则不允许对它执行unlock操作，也不允许去unlock一个被其他线程锁定的变量。

（8）对一个变量执行unlock操作之前，必须先把此变量同步回主内存（执行store和write操作）。

Volatile

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

特性

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

保证可见性

验证测试

package com.zjb.juc.jmm;

import java.util.concurrent.TimeUnit;

public class JMMDemo {

    public static int num = 0;
    public static void main(String[] args) {
        new Thread(()->{
            while(num == 0){

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

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

        num = 1;

        System.out.println(num);
    }
}

我们发现程序执行完之后，程序并没有停止，这是因为A线程并不知道主内存中已经发生了变化。

那如何让A线程知道主内存中的值已经发生变化了呢？

package com.zjb.juc.jmm;

import java.util.concurrent.TimeUnit;

public class JMMDemo {

    public volatile static int num = 0;
    public static void main(String[] args) {
        new Thread(()->{
            while(num == 0){

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

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

        num = 1;

        System.out.println(num);
    }
}

这样就可以让A线程知道主内存中的值已经发生了变化，保证可见性。

不保证原子性

package com.zjb.juc.jmm;

public class VDemo {
    public volatile static int num = 0;

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

    public static void main(String[] args) {
        for (int i = 0; i <20 ; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        while(Thread.activeCount()>2){
            Thread.yield();
        }

        System.out.println(Thread.currentThread().getName()+"=>"+num);
    }
}

通过测试发现，每次执行得到的结果都是不一样，而且也并不是真正想要的结果。

那我们怎么才能保证它的原子性呢？（在不使用lock，synchronized的前提下）

package com.zjb.juc.jmm;

import java.util.concurrent.atomic.AtomicInteger;

public class VDemo {
    //AtomicInteger 原子类，保证原子性
    public volatile  static AtomicInteger num = new AtomicInteger();

    public static void add(){
        num.getAndIncrement();
    }

    public static void main(String[] args) {
        for (int i = 0; i <20 ; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        while(Thread.activeCount()>2){
            Thread.yield();
        }

        System.out.println(Thread.currentThread().getName()+"=>"+num);
    }
}

原子类的底层都和操作系统挂钩，它是在内存中修改值。Unsafe是一个很特殊的存在。

指令重排

指令重排：所有的程序，计算机并不是按照你写的那样去执行的

源代码--》编译器优化重排--》指令并行重排--》内存系统重排--》执行

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

volatile可以避免指令重排：由于内存屏障，可以保证避免指令重排的现象产生。

作用：

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

2.可以保证某些变量的内存可见性。

排查死锁

1.jps -l 查看进程号。

2.jstack 进程号查看栈信息。

一条没有梦想的闲鱼

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程进阶

线程、进程说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。而进程则是执行程序的一次执行过程，他是一个动态的概念。是系统资源分配的单位通常在一个进程中可以包含若干个线程，当然一个进程至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位java默认有两个线程：main、gc通过查看源代码可知，java不能开启线程，java是通过调用本地方法开启的线程。代码如下： public synchronized void start
复制链接

扫一扫

专栏目录