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

一、基础概念

1.CPU核心数和线程数的区别

线程数是一种逻辑的概念，简单地说，就是模拟出的CPU核心数。比如，可以通过一个CPU核心数模拟出2线程的CPU，也就是说，这个单核心的CPU被模拟成了一个类似双核心CPU的功能。我们从任务管理器的性能标签页中看到的是两个CPU。

对于一个CPU，线程数总是大于或等于核心数的。一个核心最少对应一个线程，但通过超线程技术，一个核心可以对应两个线程，也就是说它可以同时运行两个线程。

CPU的线程数概念仅仅只针对Intel的CPU才有用，因为它是通过Intel超线程技术来实现的，最早应用在Pentium4上。如果没有超线程技术，一个CPU核心对应一个线程。所以，对于AMD的CPU来说，只有核心数的概念，没有线程数的概念。                         

CPU之所以要增加线程数，是源于多任务处理的需要。线程数越多，越有利于同时运行多个程序，因为线程数等同于在某个瞬间CPU能同时并行处理的任务数。 

2.CPU时间片轮转机制（RR调度）（上下文切换，每次切换大概需要5000~20000个时钟周期）

时间片轮转法（Round-Robin，RR）主要用于分时系统中的进程调度。为了实现轮转调度，系统把所有就绪进程按先入先出的原则排成一个队列。新来的进程加到就绪队列末尾。每当执行进程调度时，进程调度程序总是选出就绪队列的队首进程，让它在 CPU 上运行一个时间片的时间。时间片是一个小的时间单位，通常为 10~100ms 数量级。当进程用完分给它的时间片后，系统的计时器发出时钟中断，调度程序便停止该进程的运行，把它放入就绪队列的末尾；然后，把 CPU 分给就绪队列的队首进程，同样也让它运行一个时间片，如此往复。

3.什么是进程和线程

进程：程序运行资源分配的最小单位，进程内部有多个线程，会共享这个进程的资源。

线程：CPU调度的最小单位，必须依赖进程而存在。

4.并行和并发的区别

并发当有多个线程在操作时,如果系统只有一个CPU,则它根本不可能真正同时进行一个以上的线程，它只能把CPU运行时间划分成若干个时间段,再将时间 段分配给各个线程执行，在一个时间段的线程代码运行时，其它线程处于挂起状。.这种方式我们称之为并发(Concurrent)。

并行：当系统有一个以上CPU时,则线程的操作有可能非并发。当一个CPU执行一个线程时，另一个CPU可以执行另一个线程，两个线程互不抢占CPU资源，可以同时进行，这种方式我们称之为并行(Parallel)。

5.高并发编程的意义好处和注意事项

好处：充分利用cpu的资源、加快用户响应的时间，程序模块化，异步化。

问题：线程共享资源，存在冲突；容易导致死锁；启用太多的线程，就有搞垮机器的可能。

二、JAVA里的线程

1.启动线程的三种方式

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

public class NewThread {
    /**
     * 继承Thread类，由于java是单继承，多实现，可以考虑实现接口的方式
     */
    private static class OneThread extends Thread{
        @Override
        public void run() {
            System.out.println("继承Thread"+"当前线程为："+Thread.currentThread().getId());
        }
    }

    /**
     * 实现Runnable接口，Runnable和Callable的区别：有无返回值
     */
    private static class TwoThread implements Runnable{
        @Override
        public void run() {
            System.out.println("实现Runnable"+"当前线程为："+Thread.currentThread().getId());
        }
    }

    /**
     * 实现Callable接口
     */
    private static class ThreeThread implements Callable{
        @Override
        public Object call() throws Exception {
            System.out.println("实现Callable"+"当前线程为："+Thread.currentThread().getId());
            return "实现Callable接口返回参数";
        }
    }

    public static void main(String[] args) {
        //继承Thread类
        new OneThread().start();
        //实现Runnable接口
        new Thread(new TwoThread()).start();
        //实现Callable接口
        FutureTask futureTask = new FutureTask(new ThreeThread());
        new Thread(futureTask).start();
        Object o = null;
        try {
            o = futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(o);

    }
}

2.停止线程的方式（推荐interrput）

public class EndThread {

    private static class OneThread extends Thread{
        @Override
        public void run() {
            /**
             * Thread.interrupted() 静态方法，执行后具有将状态标识清除为false的功能
             * this.isInterrupted() 判断线程中断标识位，但是不能清除状态标识。
             */
            while(!this.isInterrupted()){
                System.out.println("继承Thread"+"当前线程为："+Thread.currentThread().getId()+" is run");
                System.out.println("继承Thread"+"当前线程为："+Thread.currentThread().getId()+" 。。。");
            }
        }
    }

    private static class TwoThread implements Runnable{
        @Override
        public void run() {
            while(!Thread.interrupted()){
                System.out.println("实现Runnable"+"当前线程为："+Thread.currentThread().getId()+" is run");
                System.out.println("实现Runnable"+"当前线程为："+Thread.currentThread().getId()+" 。。。");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //如果线程处于阻塞状态，调用了中断方法，抛出异常后会将中断标识位置为false，需再次调用中断方法
                    Thread.interrupted();
                    e.printStackTrace();
                }
            }

        }
    }

    public static void main(String[] args) throws Exception {
        OneThread oneThread = new OneThread();
        oneThread.start();
        Thread.sleep(1000);
        oneThread.interrupt();

        Thread twoThread = new Thread(new TwoThread());
        twoThread.start();
        Thread.sleep(1000);
        twoThread.interrupt();
    }
}