多线程

多线程

多线程概述

什么是进程？

进程是一个执行的应用程序

什么是线程？

线程是一个进程的执行场景/执行单元

一个进程可以启动多个线程

对于java程序来说，在DOS命令窗口中输入：

java HelloWorld 回车之后

会先启动JVM，而JVM就是一个进程

JVM在启动一个主线程main方法。

同时在启动一个垃圾回收线程负责看护，回收垃圾。

现在的java程序中最少有两个线程并发

一个是垃圾回收，一个是main方法

例子：

​ 阿里巴巴：进程

​ 马云：阿里巴巴的一个线程

​ 童文红：阿里巴巴的一个线程

就是说，线程依赖于进程

注意：

​ 线程A和线程B独立不共享（每个人都有各自的秘密）

​ 线程A和线程B在java语言中：堆内存和方法区内存共享，但是栈内存独立，一个线程一个栈，主线程（main）对应主栈，当主栈中的方法调用启动另外的线程后会创建分支线程（栈），两个栈之间互不干扰

10个线程会有10个栈，栈之间互不干扰

并发就像卖票，多个窗口同时卖，也就是多个线程同时执行

线程的存在就是为了提高程序的出来效率

使用了多线程机制之后，main方法结束，主栈空了，其他线程可能还在压栈，弹栈

t1线程执行t1的

t2线程执行t2的

t1不会影响t2，t2也不会影响t1。这叫做真正的多线程并发

4核cpu就表示可以有4个进程同时并发执行

单核cpu不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉

对于单核cpu来说，在某一个时间点上实际上只能处理一件事情，但是由于cpu处理的速度极快，多个进程和线程之间频繁切换执行，给人的根据就行多线程并发，实际上只是人感觉不出来而已

Java语言中实现线程有两种方式

java支持多线程机制，并已经封装好了，我们只需要去实现就行了

第一种方式：编写一个类，实现java.lang.Thread,重写run方法

//定义线程类
class MyThread extends Thread{
   
    @Override
    public void run(){
   
        //编写程序，这段程序运行在分支线程中（分支栈）
        for(int i = 0; i<1000; i++){
   
            System.out.println("分支线程-->"+i);
        }
    }
}
class ThreadTest{
   
    public static void main(String[] args){
   
        //这里是main方法，属于主线程，在主栈中运行
        //新建一个分支线程对象
        MyThread myThread = new MyThread();
        //启动一个分支线程，在JVM中开辟一个新的栈空间，这段只是为了开启一个新的栈空间，只要新的栈空间开辟处理start()方法瞬间就结束了
        myThread.start();
        //以下代码是运行在主线程中的
        for(int i = 0; i<1000; i++){
   
            System.out.println("主线程-->"+i);
        }
    }
}
//以上输出有先有后
//分布不均匀
//这是因为控制台只要一个，看谁先抢到执行权和抢占时间的不同，就会出现分布不均匀和有先有后的样子

线程启动成功后会自动调用run方法，并且run方法在分支栈的栈底部（压栈），分支栈中的run方法相当于主栈中的main方法，run和main是平级

直接调用run方法不会开启并发，只是单纯的调用方法

它们之间的执行顺序是，main执行到start()方法后开辟分支栈后，分支栈会跟着主栈剩余代码一起执行，而不是进入run方法后执行完再执行main中剩余代码

亘古不变的道理，代码是由上往下顺序执行的

第二种方式：编写一个类，实现java.lang.Runnable接口，实现run方法

//定义一个可运行的类继承Runnable接口，这个类还不能算线程类
class MyRunnable implements Runnable{
   
    @Override
    public void run(){
   
        //编写程序，这段程序运行在分支线程中（分支栈）
        for(int i = 0; i<1000; i++){
   
            System.out.println("分支线程-->"+i);
        }
    }
}
class ThreadTest{
   
    public static void main(String[] args){
   
        //创建线程对象Thread，将实现了Runnable接口的类封装成一个线程类
        Thread thread = new Thread(new MyRunnable());
        thread.start();
        for(int i = 0; i<1000; i++){
   
            System.out.println("主线程-->"+i);
        }
    }
}

两种方式都可以实现，不过推荐第二种，因为java是单继承多实现，如果你继承了Thread方法，若是还需要继承另外的方法将无法写，而采用第二种方法因为是多实现，所以不会有影响

采用匿名内部类方式实现线程：

Thread t = new Thread(new Runnable(){
   
	@Override
	public void run(){
   
		for(int i = 0; i<1000; i++){
   
			System.out.println("分支线程-->"+i);
		}
	}
})
t.start();

线程的生命周期

线程的生命周期包括5种状态：

新建状态：使用new关键字创建线程

就绪状态：使用start()方法开辟分支栈，又叫做可运行状态，具有抢夺cpu时间片（执行权）的权力。

运行状态：当线程抢夺到时间片后表示进入运行状态，或者是执行run()方法后，当占用时间片用完后，会重新回到就绪状态抢夺时间片，当再次抢到时间片后会重新进入run方法接着上一次的代码继续往下执行

阻塞状态：线程调用sleep()方法主动放弃所占有的cpu时间片

​ 调用一个阻塞式IO方法

​ 线程试图获得一个同步监视器

​ 线程在等待某个通知（notify）

​ 程序调用了线程的suspend()方法将该线程挂起

​ 解除阻塞：会回复就绪状态重新抢夺cpu时间片

​ sleep()指定时间结束

​ 线程调用的阻塞示IO方法已经返回

​ 线程成功获得同步监视器

​ 线程获取通知

​ 挂起状态的线程被恢复(resdme())

死亡状态：run或call()方法执行完成，线程正常结束

​ 线程抛出一个为捕获的Exception或Error

​ 直接调用该线程的stop方法结束该线程（任意导致死锁）

<