并发编程[1]—基础篇

一、线程基础、线程之间的共享和协作

1.1 基础概念

CPU核心数和线程数的关系
核心数:线程数=1:1 ;使用了超线程技术后—> 1:2

CPU时间片轮转机制
又称RR调度，会导致上下文切换
（CPU分给配置线程的运行时间：时间片即CPU分配给各个程序的时间，每个线程被分配一个时间段，称作它的时间片，即该进程允许运行的时间，使各个程序从表面上看是同时进行的。如果在时间片结束时进程还在运行，则CPU将被剥夺并分配给另一个进程。如果进程在时间片结束前阻塞或结束，则CPU当即进行切换。而不会造成CPU资源浪费。在宏观上：我们可以同时打开多个应用程序，每个程序并行不悖，同时运行。但在微观上：由于只有一个CPU，一次只能处理程序要求的一部分，如何处理公平，一种方法就是引入时间片，每个程序轮流执行。）

什么是进程和线程
进程：程序运行资源分配的最小单位，进程内部有多个线程，会共享这个进程的资源
线程：CPU调度的最小单位，必须依赖进程而存在。

并行和并发
并行：同一时刻，可以同时处理事情的能力
并发：与单位时间相关，在单位时间内可以处理事情的能力
（eg: 高速公路有四车道，那就可以并行4辆车；假如某长度路段，一个小时可以通过20辆车，那并发数就是80）

高并发编程的意义、好处和注意事项
好处：充分利用cpu的资源、加快用户响应的时间，程序模块化，异步化
问题：
线程共享资源，存在冲突；
容易导致死锁；
启用太多的线程，就有搞垮机器的可能

一个main方法包含的线程数：

package service;

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;

public class OnlyMain {
    public static void main(String[] args) {
        //虚拟机线程管理的接口
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        ThreadInfo[] threadInfos =
                threadMXBean.dumpAllThreads(false, false);
        for (ThreadInfo threadInfo : threadInfos) {
            System.out.println("[" + threadInfo.getThreadId() + "]" + " "
                    + threadInfo.getThreadName());
        }
    }

}

"C:\Program Files\Java\jdk1.8.0_131\bin\java" "-javaagent:D:\IntelliJ IDEA 2017.2.6\lib\idea_rt.jar=12505:D:\IntelliJ IDEA 2017.2.6\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_131\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\rt.jar;E:\projectCode\target\classes" service.OnlyMain
[6] Monitor Ctrl-Break
[5] Attach Listener
[4] Signal Dispatcher
[3] Finalizer
[2] Reference Handler
[1] main

Process finished with exit code 0

1.2 认识Java里的线程

启动线程的方式
三种（Thread,Runnable,Callable）

package service;

public class NewThread extends Thread{
    public void run(){
        System.out.println("I am extends Thread");
    }
}

package service;

public class NewThread1 implements Runnable {
    public void run() {
        System.out.println("I am implements Runnable");
    }
}

package service;

import java.util.concurrent.Callable;

/**
 * 实现Callable接口，允许有返回值
 */
public class NewThread2 implements Callable {
    public Object call() throws Exception {
        return "I am implements Callable";
    }
}

package service;

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

public class TestDemo {
    public static void main(String[] args) {
        // 第一种
        NewThread newThread = new NewThread();
        new Thread(newThread).start();

        // 第二种
        NewThread1 newThread1 = new NewThread1();
        new Thread(newThread1).start();

        // 第三种
        NewThread2 useCall = new NewThread2();
        FutureTask<String> futureTask = new FutureTask<String>(useCall);
        new Thread(futureTask).start();
        try {
            // futureTask.get()方法是个阻塞方法
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

怎么样才能让Java里的线程安全停止工作呢？
线程自然终止：自然执行完或抛出未处理异常
stop()<停止线程>，resume()<继续执行>,suspend()<挂起线程>已不建议使用，stop()会导致线程不会正确释放资源，suspend()容易导致死锁。

java线程是协作式，而非抢占式
调用一个线程的interrupt() 方法中断一个线程，并不是强行关闭这个线程，只是跟这个线程打个招呼，将线程的中断标志位置为true，线程是否中断，由线程本身决定。
isInterrupted() 判定当前线程是否处于中断状态。
static方法interrupted() 判定当前线程是否处于中断状态，同时中断标志位改为false。

package service.duoxiancheng;

public class UserThread extends Thread {
    public void run(){
        String name = Thread.currentThread().getName();
        //isInterrupted() 判定当前线程是否处于中断状态。
        while (!isInterrupted()){
            System.out.println("线程UserThread：" + name + "中断标志位是" + isInterrupted());
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println("catch an InterruptedException" + e.getMessage());
                // 当方法抛出InterruptedException异常时，线程的中断位会被复位成为false，所以需要我们在catch中自己中断
                // 重新调用interrupt()方法
                interrupt();
            }
        }
        System.out.println("线程UserThread：" + name + "中断标志位是" + isInterrupted());
    }
}

package service.duoxiancheng;

public class UserRunnableThread implements Runnable {
    public void run() {
        String name = Thread.currentThread().getName();
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("线程UserRunnableThread：" + name + "中断标志位是" + Thread.currentThread().isInterrupted());
        }
        System.out.println("线程UserRunnableThread：" + name + "中断标志位是" + Thread.currentThread().isInterrupted());
    }
}

package service.duoxiancheng;

public class InterRuptImpl {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new UserRunnableThread());
        thread.start();
        Thread.sleep(1000);
        thread.isInterrupted();


        Thread thread1 = new Thread(new UserThread());
        thread1.start();
        System.out.println(thread1.isInterrupted());
        Thread.sleep(1000);
        //调用一个线程的interrupt() 方法中断一个线程，并不是强行关闭这个线程，
        // 只是跟这个线程打个招呼，将线程的中断标志位置为true，线程是否中断，由线程本身决定。
        thread1.interrupt();
        System.out.println(thread1.isInterrupted());
    }
}

1.3 线程常用方法和线程的状态

线程只有5种状态。整个生命周期就是这几种状态的切换。

run()和start() ：run方法就是普通对象的普通方法，只有调用了start()后，Java才会将线程对象和操作系统中实际的线程进行映射，再来执行run方法。
yield() ：让出cpu的执行权，将线程从运行转到可运行状态，但是下个时间片，该线程依然有可能被再次选中运行。
线程的优先级
取值为1~10，缺省为5，但线程的优先级不可靠，不建议作为线程开发时候的手段
守护线程
和主线程共死，finally不能保证一定执行

二、线程间的共享

2.1 synchronized内置锁

对象锁，锁的是类的对象实例。
类锁 ，锁的是每个类的的Class对象，每个类的的Class对象在一个虚拟机中只有一个，所以类锁也只有一个。

2.2 volatile关键字

《补充：首先并发编程有三个特点，1.原子性2.有序性3.可见性。该关键字保证了可见性和有序性。具体细节需要了解虚拟机，改天找篇通俗易懂的博客贴在这，^_ 墙裂推荐（https://www.cnblogs.com/dolphin0520/p/3920373.html）》
适合于只有一个线程写，多个线程读的场景，因为它只能确保可见性。

2.3 ThreadLocal

线程变量。可以理解为是个map，类型 Map<Thread,Integer>
ThreadLocal用于保存某个线程共享变量：对于同一个static ThreadLocal，不同线程只能从中get，set，remove自己的变量，而不会影响其他线程的变量。
1、ThreadLocal.get: 获取ThreadLocal中当前线程共享变量的值。
2、ThreadLocal.set: 设置ThreadLocal中当前线程共享变量的值。
3、ThreadLocal.remove: 移除ThreadLocal中当前线程共享变量的值。
4、ThreadLocal.initialValue: ThreadLocal没有被当前线程赋值时或当前线程刚调用remove方法后调用get方法，返回此方法值。

三、线程间协作

轮询：
难以保证及时性，资源开销很大，
等待和通知
wait() 对象上的方法
notify/notifyAll 对象上的方法

3.1 等待和通知的标准范式

等待方：
1、 获取对象的锁；
2、 循环里判断条件是否满足，不满足调用wait方法，
3、 条件满足执行业务逻辑
通知方来说
1、 获取对象的锁；
2、 改变条件
3、 通知所有等待在对象的线程

3.2 notify和notifyAll应该用谁？

应该尽量使用notifyAll，使用notify因为有可能发生信号丢失的的情况
等待超时模式实现一个连接池
假设 等待时间时长为T，当前时间now+T以后超时

long overtime = now+T;
long remain = T;//等待的持续时间
while(result不满足条件&& remain>0){
wait(remain);
remain = overtime – now;//等待剩下的持续时间
}
return result;

join()方法
面试点
线程A执行了线程B的join方法，线程A必须要等待B执行完成了以后，线程A才能继续自己的工作

3.3 调用yield() 、sleep()、wait()、notify()等方法对锁有何影响？

面试点
线程在执行yield()以后，持有的锁是不释放的
sleep()方法被调用以后，持有的锁是不释放的
调动方法之前，必须要持有锁。调用了wait()方法以后，锁就会被释放，当wait方法返回的时候，线程会重新持有锁
调动方法之前，必须要持有锁，调用notify()方法本身不会释放锁的

四、Fork-Join

4.1 什么是分而治之？

规模为N的问题，N<阈值，直接解决，N>阈值，将N分解为K个小规模子问题，子问题互相对立，与原问题形式相同，将子问题的解合并得到原问题的解
动态规范

工作密取
workStealing

4.2 Fork/Join 使用的标准范式

Fork/Join的同步用法同时演示返回结果值：统计整形数组中所有元素的和
Fork/Join的异步用法同时演示不要求返回值：遍历指定目录（含子目录）寻找指定类型文件

4.3 代码演示：同步调用有返回值

package com.thread.fork;
 
import java.util.Random;
 
public class ThreadArray {
    // 数组长度
    public static final int ARRAY_LENGTH = 400;
 
    public static int[] makeArray() {
        Random random = new Random();
        int[] result = new int[ARRAY_LENGTH];
        for (int i = 0; i < ARRAY_LENGTH; i++) {
            result[i] = random.nextInt(ARRAY_LENGTH * 3);
        }
        return result;
    }
}

package com.thread.fork;
 
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
 
public class SumArrayFork {
 
    private static class SumTask extends RecursiveTask<Integer> {
        // 阈值
        private final static int THRESHOLD = ThreadArray.ARRAY_LENGTH / 10;
        // 表示我们实际需要统计的数组
        private int[] src;
        // 开始统计数据的下标
        private int fromIndex;
        // 统计到哪里结束的小标
        private int toIndex;
 
        public SumTask(int[] src, int fromIndex, int toIndex) {
            this.src = src;
            this.fromIndex = fromIndex;
            this.toIndex = toIndex;
        }
 
        protected Integer compute() {
            if (toIndex - fromIndex < THRESHOLD) {
                int count = 0;
                for (int i = fromIndex; i <= toIndex; i++) {
                    count = count + src[i];
                }
                return count;
            } else {
                // fromIndex ...mid...toIndex
                int mid = (fromIndex + toIndex) / 2;//此处不一定非要从中间截取
                // 递归处理
                SumTask left = new SumTask(src, fromIndex, mid);
                SumTask right = new SumTask(src, mid + 1, toIndex);
                invokeAll(left, right);
                return left.join() + right.join();
 
            }
        }
    }
 
    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();
        int[] src = ThreadArray.makeArray();
        SumTask sumTask = new SumTask(src, 0, src.length - 1);
        long startTime = System.currentTimeMillis();
        pool.invoke(sumTask);
        int result = sumTask.join();
        long endTime = System.currentTimeMillis() - startTime;
        System.out.println("endTime:" + endTime + "::::result:" + result);
    }
}
 
// 输出：endTime:2::::result:224062

package com.thread.fork;
 
/**
 * 求出数组中元素的和
 *
 */
public class SumArrayNormal {
    public static void main(String[] args) throws InterruptedException {
        int conunt = 0;
        int [] srcArray = ThreadArray.makeArray();
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < srcArray.length; i++) {
            conunt = conunt + srcArray[i];
        }
        long endTime = System.currentTimeMillis()-startTime;
        System.out.println("cost Time:"+endTime);
        System.out.println("resutl:"+conunt);
    }
}
 
// 输出：cost Time:0:::resutl:234607

1.采用Fork-join时，为什么不比单线程快，因为多线程时，虚拟机需要上下文切换导致浪费时间，单线程执行需要执行独立单个任务即可。

2.RecursiveTask和RecursiveAction的区别

RecursiveTask有返回值

RecursiveAction无返回值

Fork-join的异步用法:

package com.thread.formasy;
 
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
 
public class FindDirsFile extends RecursiveAction {
 
    private File path;//当前任务需要搜寻的目录
 
    public FindDirsFile(File path) {
        this.path = path;
    }
 
    public static void main(String[] args) {
        try {
            // 用一个 ForkJoinPool 实例调度总任务
            ForkJoinPool pool = new ForkJoinPool();
            FindDirsFile task = new FindDirsFile(new File("E:/"));
 
            pool.execute(task);//异步调用
 
            System.out.println("Task is Running......");
            Thread.sleep(1);
            int otherWork = 0;
            for (int i = 0; i < 100; i++) {
                otherWork = otherWork + i;
            }
            System.out.println("Main Thread done sth......,otherWork=" + otherWork);
            task.join();//阻塞的方法
            System.out.println("Task end");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
 
    @Override
    protected void compute() {
        List<FindDirsFile> subTasks = new ArrayList<>();
 
        File[] files = path.listFiles();
        if (files != null) {
            for (File file : files) {
                if (file.isDirectory()) {
                    subTasks.add(new FindDirsFile(file));
                } else {
                    //遇到文件，检查
                    if (file.getAbsolutePath().endsWith("txt")) {
                        System.out.println("文件：" + file.getAbsolutePath());
                    }
                }
            }
            if (!subTasks.isEmpty()) {
                for (FindDirsFile subTask : invokeAll(subTasks)) {
                    subTask.join();//等待子任务执行完成
                }
            }
        }
    }
}

异步采用的方法是excute

运行结果：