Java —多线程

1.线程与进程的概念

进程：操作系统中的一个程序的执行周期。
线程：一个进程同时执行多个任务。通常来讲，每一个任务就称为一个线程。

• 进程与线程比较：

1.与进程相比，线程更加的“轻量级”，创建、撤销一个线程比启动、撤销一个进程开销要小得多。一个进程中的所有线程共享此进程的所有资源。

2.没有进程就没有线程，进程一旦终止，其内的线程也将不复存在。

3.进程是操作系统资源调度的基本单位，进程可以独享资源；

线程需要依托进程提供的资源，无法独立申请操作系统资源，是OS任务执行的基本单位。

主方法就是主线程。

多进程：多个程序可以同时执行。（windows是一个多进程的操作系统）
多线程应用：例如，一个浏览器应用可以同时下载多个图片、音乐；一个Web服务器需要同时处理多个并发的请求。这些都是多线程的应用。

高并发：访问的线程量非常非常高。
高并发带来的问题：服务器内存不够用，无法处理新的请求。

2.Java多线程实现

2.1继承Thread类实现多线程

java.long.Thread是线程操作的核心类。新建一个线程最简单的方法就是直接继承Thread，而后覆写run（）方法（相当于主线程的main()方法）。
Thread的run（）方法是：public void run();

我们发现，左图是直接调用的run（）,发现是顺序执行，这并不是多线程。
所以：

• 无论哪种方式实现多线程，线程启动一定调用Thread类提供的start()方法！

• 线程的start方法只能调用一次，多次调用会Java.long.IllegalThreadStateException（抛出线程非法异常）

• start（Java方法）—> start0(JVM) —> 进行资源调度，系统分配（JVM）—> run（java方法）执行线程的具体操作任务。

2.2 实现Runnable接口来实现多线程

Runnable是个接口，所以它的run（）方法是个抽象方法，
表达形式：public abstract void run();
实现接口仍然是：public void run（）；
强调：无论哪种方式实现多线程，线程启动一定调用Thread类提供的start()方法！

class MyThread implements Runnable{
    private String title;

    public MyThread(String title) {
        this.title = title;
    }
    public void run(){
        for(int i = 0;i<5;i ++){
            System.out.println(this.title+":"+i);
        }
    }
}
public class Test1{
    public static void main(String[] args) {
        MyThread thread1 = new MyThread("线程1");
        MyThread thread2 = new MyThread("线程2");
        MyThread thread3 = new MyThread("线程3");
        new Thread(thread1).start();
        new Thread(thread2).start();
        new Thread(thread3).start();

    }
}
运行结果：
线程2:0
线程2:1
线程1:0
线程2:2
线程3:0
线程2:3
线程1:1
线程2:4
线程3:1
线程3:2
线程3:3
线程3:4
线程1:2
线程1:3
线程1:4

此时，JVM里面有4个线程，主方法也是一个线程（主线程）。子线程是通过主线程启动。

下面这几种方法都可以实现Runnable接口。

//通过匿名内部类实现Runnable接口
public class Test1{
    public static void main(String[] args) {
       Runnable runnable = new Runnable() {
           //匿名内部类
           @Override
           public void run() {
               System.out.println("hehe");
           }
       };
       new Thread(runnable).start();
    }
}

public class Test1{
    public static void main(String[] args) {
       Runnable runnable = ()-> System.out.println("hehe");
       new Thread(runnable).start();
    }
}

public class Test1{
    public static void main(String[] args) {
       new Thread(()-> System.out.println("hehe")).start();
    }
}

2.3 继承Thread类和实现Runnable接口关系

a) Thread类与自定义线程类（实现了Runnable接口），是一个典型的代理设计模式。

Thread类负责辅助真实业务操作（资源调度，创建线程并启动）
自定义线程类负责真实业务的实现（run方法具体要干什么）。

b) 使用Runnable接口实现的多线程程序类可以更好的描述共享的概念。

2.4 实现Callable接口实现多线程（juc）—当线程有返回值时只能实现Callable实现多线程

• juc—JDK1.5新增的高并发程序编程包**
  java.util.concurrent.Callable

• 实现Callable而后覆写call（）方法，有返回值
  V call( ) throws Exception

由于Thread类没有Callable接口，我们要将MyThread 和Thread建立起联系，如图：

• Future接口：
  V get( ) throws InterruptedException,ExecutionException;

取得Callable接口的返回值，有Callable接口一定会有future接口，它俩是搭配使用的。

3.多线程常用操作方法

3.1 线程命名与取得

I) 通过构造方法在创建线程时设置线程名称

public Thread(String name)

public Thread(Runnable target,String name)

II) 取得线程名称

public final String getName()

III) 设置线程名称

public final synchronized void setName(String name)

3.2线程休眠方法sleep( long time)—单位为毫秒running->blocked

public static native void sleep(long millis) throws InterruptedException;

线程休眠：让当前线程暂缓执行，等到了预计时间后再恢复执行。

class MyThread implements Runnable{
    public void run(){
        for(int i =0;i<3;i++){
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {