java高并发学习总结

什么是并发

1 并发就是指程序同时处理多个任务的能力。
2 并发编程的根源在于对多个任务情况下对访问资源的有效控制。

程序、进程与线程

程序是静态概念，windows下通常指exe文件。
进程是动态概念，是程序在运行状态，进程说明程序在内存中的边界。
线程是进程内的一个“基本任务”，每个线程都有一个自己的功能，是CPU分配与调度的基本单位。

20190528171540743.png

Java中创建线程的三种方式

继承Thread类创建线程
实现Runnable接口创建线程
使用Callable和Future创建线程

20190528172440293.png

创建线程

public class TestThread extends Thread{
public void run() {
System.out.println(“Hello World”);
}
public static void main(String[] args) {
Thread mThread = new TestThread();
mThread.start();
}
}

java线程wait()和notifyAll()唤醒所有线程

public class Wait {
    public static void main(String[] args) throws InterruptedException {
         Object object = new Object();
        MThread waitThread1 = new MThread(true, object);
        MThread waitThread2 = new MThread(true, object);
        MThread waitThread3 = new MThread(true, object);
        MThread notifyThread = new MThread(false, object);
        Thread thread1 = new Thread(waitThread1, "wait线程A");
        Thread thread2 = new Thread(waitThread2, "wait线程B");
        Thread thread3 = new Thread(waitThread3, "wait线程C");
        Thread thread4 = new Thread(notifyThread, "notify线程");
        thread1.start();
        thread2.start();
        thread3.start();
        Thread.sleep(1000);
        thread4.start();
        System.out.println("main方法结束!!");

    }
}

class MThread implements Runnable {
    private boolean flag;
    private Object obj;
    public MThread(boolean flag, Object obj) {
        super();
        this.flag = flag;
        this.obj = obj;
    }

    public void waitMethod() {
        synchronized (obj) {
            try {
                while (true) {
                    System.out.println("wait方法开始" + Thread.currentThread().getName());
                    obj.wait();
                    System.out.println("wait()方法结束.. " +
                            Thread.currentThread().getName());
                    return;

                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

    public void notifyMethod() {
        synchronized (obj) {
            try {
                System.out.println("notify()方法开始.. " +
                        Thread.currentThread().getName());
              //  obj.notify();
                obj.notifyAll();
                System.out.println("notify()方法结束.. " +
                        Thread.currentThread().getName());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }


    @Override
    public void run() {
        if (flag) {
            this.waitMethod();
        } else {
            this.notifyMethod();
        }
    }
}
wait方法开始wait线程C
wait方法开始wait线程B
wait方法开始wait线程A
main方法结束!!
notify()方法开始.. notify线程
notify()方法结束.. notify线程
wait()方法结束.. wait线程A
wait()方法结束.. wait线程B
wait()方法结束.. wait线程C

中断线程

interrupt方法可以用来请求终止线程，当一个线程调用interrupt方法时，线程的中断状态将被置位。这是每个线程都具有的boolean标志，每个线程都应该不时的检查这个标志，来判断线程是否被中断。

要想弄清线程是否被置位，可以调用Thread.currentThread().isInterrupted()：
但是如果一个线程被阻塞，就无法检测中断状态。这是产生InterruptedException的地方。当一个被阻塞的线程（调用sleep或者wait)上调用interrupt方法。阻塞调用将会被InterruptedException中断。
如果每次迭代之后都调用sleep方法（或者其他可中断的方法），isInterrupted检测就没必要也没用处了，如果在中断状态被置位时调用sleep方法，它不会休眠反而会清除这一状态并抛出InterruptedException。所以如果在循环中调用sleep,不要去检测中断状态，只需捕获InterruptedException。

while(!Thread.currentThread().isInterrupted()){
do something
}

void myTask()throw InterruptedException{
sleep(50)
}

并发工具包-Concurrent

  Jdk5以后我们专门提供了一个并发工具包java.util.concurrent
  java.util.concurrent 包含许多线程安全的、测试良好、高性能的并发构建快，创建concurrent的目的就是要实现Collection框架对数据     结构所执行的并发操作。通过提供一组可靠的、高性能并发构建块，开发人员可以提高并发类的线程安全、可伸缩性、性能、可读性和可靠性。

Synchronized

Synchronized(同步锁)关键字的作用就是利用一个特定的对象设置一个锁lock，在多线程并发访问的时候，同时只允许一个线程可以获得这个锁，执行特定的代码。执行后释放锁，继续由其他线程争抢。
Synchronized可以使用在以下三种场景，对应不同的锁对象。

Synchronized 代码块 – 任意对象即可
Synchronized 方法 – this当前对象
Synchronized 静态方法 – 该类的字节码对象

线程的五种状态

20190528172719117.png

死锁

20190528172744653.png

ThreadPool – 线程池

重用存在的线程，减少对象对象、消亡的开销
线程总数可控，提高资源的利用率
避免过多资源竞争，避免阻塞
提供额外功能，定时执行、定期执行、监控等。

在java.util.concurrent中，提供了工具类Executors(调度器)对象来创建线程池，可以创建的线程池有四种：

CachedThreadPool – 可缓存线程池
可缓存线程的特点就是，无限大，如果线程池中没有可用的线程则创建，有空闲线程则利用起来
Shutdown() 代表关闭线程池（等待所有线程完成）
ShutdownNow() 代表立即终止线程池的运行，不等待线程，不推荐使用
FixedThreadPool – 定长线程池
定长线程池的特点就是固定线程总数，空闲线程用于执行任务，如果线程都在使用后续任务则处于等待状态在线程池中的线程如果任务处于等待状态，备选的等待算法默认 FIFO（先进先出），LIFO（后进先出）
SingleThreadExecutor – 单线程池
ScheduledThreadPool – 调度线程池

Atomic和CAS算法

1.原子性：是指一个操作或多个操作要么全部执行，且执行过程中不会被任何因素打断，要么就都不执行。

Atomic包是java.util.concurrent下的另一个专门为线程安全设计的java包，包含多个原子操作类。
Atomic常用类
AtomicInteger
AtomicIntegerArray
AtomicBoolean
AtomicLong
AtomicLongArray

 2. 锁是用来做并发最简单的方式，当然其代价也是最高的。独占锁是一种悲观锁，synchronized就是一种独占锁，他假设最坏的情况，并且只有在确保其他线程不会干扰的情况下执行，会导致其他所有需要锁的线程挂起，等待持有锁的线程释放锁。

所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项工作，如果因为冲突失败就重试，知道成功为止。其中CAS（比较与交换，Compare And Swap）是一种有名的无锁算法。

java高并发学习总结