1. 进程和线程的关系和区别

进程 是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.,例如QQ,微信等应用进程;

线程 是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源

1.1 什么是线程

public class MyThread extends Thread {
    public MyThread() {
        
    }
    public void run() {
        for(int i=0;i<10;i++) {
            System.out.println(i);
            System.out.println("main");
        }
    }
    public static void main(String[] args) {
        MyThread mThread1=new MyThread();
        MyThread mThread2=new MyThread();
        MyThread myThread3=new MyThread();
        mThread1.start();
        mThread2.start();
        myThread3.start();
 
    }
}

观察上面程序的运行结果,会看到main和数字交叉输出,这就是直观的线程;

1.1. 创建线程的方式

1.1.1. 继承Thread类实现多线程

run()为线程类的核心方法，相当于主线程的main方法，是每个线程的入口
a.一个线程调用 两次start()方法将会抛出线程状态异常，也就是的start()只可以被调用一次
b.native生明的方法只有方法名，没有方法体。是本地方法，不是抽象方法，而是调用c语言方法
registerNative()方法包含了所有与线程相关的操作系统方法
c. run()方法是由jvm创建完本地操作系统级线程后回调的方法，不可以手动调用（否则就是普通方法）

public class MyThread extends Thread {
    public MyThread() {
        
    }
    public void run() {
        for(int i=0;i<10;i++) {
            System.out.println(Thread.currentThread()+":"+i);
        }
    }
    public static void main(String[] args) {
        MyThread mThread1=new MyThread();
        MyThread mThread2=new MyThread();
        MyThread myThread3=new MyThread();
        mThread1.start();
        mThread2.start();
        myThread3.start();
    }
}

1.1.2. 覆写Runnable()接口实现多线程，而后同样覆写run().推荐此方式

a.覆写Runnable接口实现多线程可以避免单继承局限
b.当子类实现Runnable接口，此时子类和Thread的代理模式（子类负责真是业务的操作，thread负责资源调度与线程创建辅助真实业务。

public class MyThread implements Runnable{
    public static int count=20;
    public void run() {
        while(count>0) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-当前剩余票数:"+count--);
        }
    }
    public static void main(String[] args) {
        MyThread Thread1=new MyThread();
        Thread mThread1=new Thread(Thread1,"线程1");
        Thread mThread2=new Thread(Thread1,"线程2");
        Thread mThread3=new Thread(Thread1,"线程3");
        mThread1.start();
        mThread2.start();
        myThread3.start();
    }
}

继承Thread和实现Runnable接口的区别
a.实现Runnable接口避免多继承局限
b.实现Runnable()可以更好的体现共享的概念

1.1.3. 覆写Callable接口实现多线程（JDK1.5）

a.核心方法叫call()方法，有返回值
b.有返回值

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
 
public class MyThread implements Callable<String> {
    private int count = 20;
 
    @Override
    public String call() throws Exception {
        for (int i = count; i > 0; i--) {
//          Thread.yield();
            System.out.println(Thread.currentThread().getName()+"当前票数：" + i);
        }
        return "sale out";
    } 
 
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Callable<String> callable  =new MyThread();
        FutureTask <String>futureTask=new FutureTask<>(callable);
        Thread mThread=new Thread(futureTask);
        Thread mThread2=new Thread(futureTask);
        Thread mThread3=new Thread(futureTask);
//      mThread.setName("hhh");
        mThread.start();
        mThread2.start();
        mThread3.start();
        System.out.println(futureTask.get());
        
    }
}

1.1.4. 通过线程池创建

通过Executor 的工具类可以创建四种类型的普通线程池：

FixThreadPool(int n); 固定大小的线程池

使用于为了满足资源管理需求而需要限制当前线程数量的场合。使用于负载比较重的服务器。

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

public class Test {
public static void main(String[] args) {
ExecutorService ex=Executors.newFixedThreadPool(5);

    for(int i=0;i<5;i++) {
        ex.submit(new Runnable() {
            
            @Override
            public void run() {
                for(int j=0;j<10;j++) {
                    System.out.println(Thread.currentThread().getName()+j);
                }
                
            }
        });
    }
    ex.shutdown();
}   

}

SingleThreadPoolExecutor :单线程池

需要保证顺序执行各个任务的场景

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

public class Test {
public static void main(String[] args) {
ExecutorService ex=Executors.newSingleThreadExecutor();

    for(int i=0;i<5;i++) {
        ex.submit(new Runnable() {
            
            @Override
            public void run() {
                for(int j=0;j<10;j++) {
                    System.out.println(Thread.currentThread().getName()+j);
                }
                
            }
        });
    }
    ex.shutdown();
}   

}

CashedThreadPool(); 缓存线程池

当提交任务速度高于线程池中任务处理速度时，缓存线程池会不断的创建线程
适用于提交短期的异步小程序，以及负载较轻的服务器

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

public class Test {
public static void main(String[] args) {
ExecutorService ex=Executors.newCachedThreadPool();

    for(int i=0;i<5;i++) {
        ex.submit(new Runnable() {
            
            @Override
            public void run() {
                for(int j=0;j<10;j++) {
                    System.out.println(Thread.currentThread().getName()+j);
                }
                
            }
        });
    }
    ex.shutdown();
}   

}

ScheduledThreadPool:定时器线程池

// 测试固定延迟的多线程定时器
private static void testMultiScheduleDelay() {
    // 创建一个固定速率的多线程定时器（线程池大小为3）
    ScheduledExecutorService pool = (ScheduledExecutorService) Executors.newScheduledThreadPool();
    for (int i=0; i<5; i++) { // 循环开展5个调度
        // 创建一个参观任务
        Visit visit = new Visit("固定延迟的多线程定时器", i);
        // 命令线程池开展任务调度。第一次延迟1秒后执行参观任务，以后每3秒执行下一个参观任务
        pool.scheduleWithFixedDelay(visit, 1, 3, TimeUnit.SECONDS);
    }
}

1.1.5. 线程的状态

线程状态总共有5种

线程的状态
1.新建:new一个新的线程时,还没有调用start()该线程会处于创建状态
2.就绪(RUNNABLE)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。

3.运行(RUNNING)：可运行状态(runnable)的线程获得了cpu 时间片（timeslice） ，执行程序代码。
4.阻塞(BLOCKED)：阻塞状态是指线程因为某种原因放弃了cpu 使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。阻塞的情况分三种：

(一). 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。
(二). 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
(三). 其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。
5.死亡(DEAD)：线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生
上面这些状态都是由JVM管理的