多线程

多线程

多线程概述

什么是进程？

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

什么是线程？

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

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

对于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方法结束该线程（任意导致死锁）

参考：https://www.cnblogs.com/sunddenly/p/4106562.html

线程在就绪和运行中频繁切换

线程的常用方法

设置线程名字：setName()

当线程没有设置名字时，线程的默认名字是 Thread-1，Thread-2，Thread-3……

获取当前线程对象：getName()

获取线程对象：static Thread currentThread();

MyThread mt1 = new MyThread();
mt1.setName("aa");
mt1.start()//Thread.currentThread().getName()就是mt1
//修改了mt1线程名后获取线程名就是aa
MyThread mt2 = new myThread();
mt2.start();//Thread.currentThread().getName()就是mt2
//t就是当前线程对象
//这个方法出现在哪个线程对象中就是哪个线程
class MyThread extents Thread{
    @Override
    public void run(){
        Thread currentThread = Thread.currentThread();
       	System.out.println(currentThread.getName());
    }
}

修改线程对象：修改就是用setName()方法设置线程名

线程休眠：sleep() 静态方法，参数是毫秒

​ 让当前线程进入休眠，进入阻塞状态，放弃占有cpu时间片，让给其他线程使用Thread.sleep(1000);让线程休眠1秒，1秒钟后再继续执行线程剩余方法

间隔特定的时间，去执行特定的一段代码

sleep()面试题

Thread t = new MyThread();
t.setName("t");
t.start();
t.sleep(1000*5);//sleep()会不会让t进入休眠
class MyThread extends Thread{
	public void run(){
		for(int i = 0; i<1000; i++){
			System.out.println(Thread.currentThread().getName()"--->"+i);
		}
	}
}

sleep的作用是人当前线程进入休眠，跟t对象无关，会变成Thread.sleep()，进入休眠的是main方法，不是MyThread()方法

run()当中的异常不能throws，只能try-catch

因为run()方法再父类中没有抛出任何异常，子类不能比父类抛出更多的异常

唤醒正在sleep的线程：对象名.interrupt()

终断线程的睡眠（这种方法依靠异常处理机制）

interrupt()会让sleep报异常，进入异常处理，结束掉sleep

强行终止一个线程的执行：对象名.stop()

缺点：容易丢失数据，因为这个方法是将线程直接杀死，线程没有保存的数据将会丢失，不建议使用

合理终止一个线程的执行（常用）：打一个全局布尔变量标记，任何给run方法中的代码一个if-else先让变量等于true，如果你想停了，修改布尔变量为false即可终止，else用来return终止else中也可以保存线程没执行完想保存的

MyThread mt = new MyThread();
mt.start();
try{
    Thread.sleep(5000);
}catch(InterruptedException e){}
mt.b = false;
class MyThread extends Thread{
    boolean b = true;
    @Override
    public void run(){
        for(int i = 0; i<10; i++){
        	if(b){
            	System.out.println(Thread.currentThread().getName()+"--->"+i);
                try{
                    Thread.sleep(1000);
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
        	}else{
                //还有什么没保存的，在这里保存
                //终止当前线程
                return;
            }
    	}
    }
}

线程调度概述

常见线程调度模型：

• 抢占式调度模型：哪个线程优先级比较高，抢到的cpu时间片的概率高一些。java采用的就是抢占式调度模型
• 均分式调度模型：平均分配cpu时间片：每个线程占据的cpu时间片时间长度一样

线程调度方法：实例方法 setPriority()设置线程的优先级

获取线程优先级：实例方法 getPriority()

线程优先级：最低是1，默认是5.最高是10

常量：NORM_PRIORITY分配默认优先级 5Thread.NORM_PRIORITY

​ MAX_PRIORITY分配最高优先级 10Thread.MAX_PRIORITY

​ MIN_PRIORITY分配最低优先级 1Thread.MIN_PRIORITY

暂停当前线程方法并执行其他线程：静态方法 yieId()让位方法，不是阻塞方法，会让线程从运行状态回到就绪状态,会重新抢cpu时间片

合并线程：join()让当前线程进入阻塞，另外的线程先执行，直到另一个线程执行完在执行当前线程

class MyThread extends Thread{
    @Override
    public void run(){
        for(int i = 0; i<10; i++){
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
}

public static void main(String[] args){
	MyThread mt = new MyThread();
        mt.start();
        try {
            mt.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i = 0; i<10; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
}

多线程并发环境下，数据的安全（重点）

开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程启动等，都已经实现完，这些都不需要我们去编写代码的。

最重要的是：数据在多线程并发环境下是否安全

什么时候多线程在并发环境下会出现问题？

就像售票时，两个售票员同时出售同一张票，出售完后才发现两人出售了同一张票，这就是并发带来的安全问题

当你抢微信红包时，你点开后收到了前但是网络卡了，余额更新不及时，后面又来了一个人也抢了这个红包，因为余额更新不及时所以钱还在那，你同样可以抢，等第一个人好后数据提交上去发现一个红包被领了两次同等的金额，这就是线程并发带来的数据安全问题

满足以下三个条件可能会存在线程安全问题：

条件1：多线程并发

条件2：有共享数据

条件3：数据有修改的行为

怎么解决线程安全问题呢

​ 可以采用线程排队执行这种方法（不能并发），这种机制被称为线程同步机制

线程同步就是线程排队，线程排队了会牺牲一部分效率

异步编程模型：

​ 线程t1和线程t2，各自执行各自的，t1和t2互不干扰，谁也不需要等谁，这种编程模型叫做：异步编程模型。

​ 其实就是：多线程并发（效率较高）

异步就是并发

同步编程模型：

​ 线程t1和线程t2，在线程t1执行时，线程t2必须等待线程t1执行结束，或者在t2线程执行时，t1必须等待t2执行完成再执行。

​ 两个线程之间发生了等待关系，这就是同步编程模型效率较低，线程排队执行。

同步就是排队

同步代码块synchronized

线程同步机制，线程排队执行

线程同步机制的语法是

synchronized(){//线程同步代码块}synchronized后面小括号中传的数据是相当关键的，这个数据必须是多线程共享的数据。才能达到多线程排队

假如有t1，t2，t3，t4，t5五个线程

t1，t2，t3需要排队，t4，t5不需要排队

那么synchronized()小括号中就需要传输t1，t2，t3三个共享的对象，而这个对象不是t4，t5共享的

synchronized()实际上就像上厕所，一个厕所有五个隔间，就有五个人可以同时上厕所，多一个都不行，只能等其中一个出来才能重新进去一个

在java语言中，任何一个对象都有一把”锁“，其实这把锁就是标记

100个对象100把锁

实际上还是就像上厕所，一个厕所有五个隔间，每个隔间带着一个锁，就有五个人可以同时上厕所，五个人就拿着五把钥匙，把隔间锁了起来，等其中一个上完厕所，锁才会释放，接着进去的那人再占用一把锁，去做相应的事（synchronized中的代码）

当线程再运行过程中遇见synchronized后会假如锁池lockpool等待找到锁池里的共享对象的对象锁，线程进入锁池找对象锁时会释放之前抢到的时间片，等有可能找到，有可能没找到，没找到会等待找到的执行完，而找到的会进入就绪状态重新去抢夺时间片

对象锁就是传入synchronized的共享对象

变量的安全问题

java中有以下三大变量：

1. 实例变量：在堆中
2. 静态变量：在方法区
3. 局部变量：在栈中

以上三大变量中局部变量永远不会存在线程安全问题，因为一个线程一个栈，栈与栈之间互不干扰

常量不可修改，所以也不会有线程安全问题

实例变量在堆中，静态变量在方法区，这两个都只有一个，是共享的，所以会存在安全问题

同步代码块越小效率越高

synchronized出现在实例方法上

public synchronized void test(){}synchronized出现在实例方法上只能是this对象，这种方法不灵活

synchronized出现在实例方法上，表示整个方法体都需要同步，可能会无辜扩大同步范围。导致程序执行效率降低，所以这种方法不常用

synchronized使用在实例代码上只能用来精简代码，如果共享的就是this对象并且需要同步的是整个方法体，建议使用这种方式

如果使用局部变量的话建议使用StringBuilder

因为局部变量不存在线程安全问题。但是StringBuilder效率比较低

ArrayList是非线程安全的

Vector是线程安全的

HashMap HashSet是非线程安全的

Hashtable是线程安全的

总结：

​ synchronized的三种写法：

1. 同步代码块

   1. 灵活

      语法：

      ​ synchronized(线程共享对象){

      ​ //同步代码块；

      ​ }

2. 在实例方法是使用synchronized

   表示共享对象一定是this（本方法）

   并且同步代码块是整个方法体

3. 在静态方法上使用synchronized

   表示找类锁

   类锁永远只要一把锁

   就是创建100个对象也只有一把锁

   排他锁：t1线程拿到线程执行权时，t2也想执行，不可能

死锁：就是将代码锁死了，没有满足的，拿不出

就是t1和t2，还有两个线程，a1，a2。

t1从上往下（a1再a2）t2从下往上（a2再a1）

t1和t2都想把a1，a2锁上，但是因为执行顺序原因，t1锁上a1后想锁上发现a2锁不上了就一直停在那没法动，t2把a2锁上后想锁上a1发现a1已经被锁上，无法锁，就这样t1，t2一直等待着能锁上另一个线程。

死锁不会出现异常和保存，因为理论上它们的代码是并没有问题的

死锁面试官一般要求你会写，以后开发中才会注意死锁

class MyThread1 extends Thread{
    Object o1;
    Object o2;
    public MyThread1(Object o1,Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run(){
        synchronized(o1){
            Thread.sleep(1000);//保证能顺利进入死锁
            synchronized(o2){
                
            }
        }
    }
}

class MyThread2 extends Thread{
    Object o1;
    Object o2;
    public MyThread2(Object o1,Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run(){
        synchronized(o2){
            Thread.sleep(1000);//保证能顺利进入死锁
            synchronized(o1){
                
            }
        }
    }
}

public static void main(String[] args){
    Object o1 = new Object();
    Object o2 = new Object();
    //t1和t2两个线程共享o1和o2
    Thread t1 = new MyThread(o1,o2);
    Thread t2 = new MyThread(o1,o2);
    t1.start();
    t2.start();
}

synchronized最好不用嵌套使用，一但失误，很容易造成死锁

开发中怎么解决线程安全问题

不是一上来就选择synchronized，会导致效率降低，再不得已的情况下再选择使用synchronized线程同步机制

第一种方案：尽量使用局部变量代替实例变量和静态变量

第二种方案：如果必须是实例变量，可以考虑创建多个对象，这样实例变量的内存就不共享了（一个线程对应一个对象，100个线程对应100个变量，对象不共享就不会存在数据安全问题了）

第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候只能选择sunchronized了。线程同步机制

守护线程

如垃圾回收线程，就是后台线程

java语言中线程分为两种：

一类是用户线程

一类是守护线程（后台线程）

其中最具有代表性的就是：垃圾回收线程（守护线程）

守护线程的特点：

​ 一般的守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束

​ main线程是一个用户线程

守护线程的用处：每隔一段时间自动执行某些有意义的操作，如备份数据，这需要用到定时器，所有的用户线程只要结束，守护线程自动结束

对象.setDaemon(true);将线程设置为守护线程

定时器

间隔一定的时间执行一定的程序，比如每周进行一次大扫除

可以使用sleep方法设置，指定睡眠时间，在指定时间做某件事。这时最原始的定时器

java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用，实际开发中已经使用较少

目前使用较多的是spring框架提供的SpringTask框架

这个框架只要进行简单的配置，就可以完成定时器的任务。

java.util.Timer：

//schedule(定时任务，第一次执行时间，延迟多久执行一次（毫秒）)
//schedule实现了Runnable接口是一个线程
//Timer()
//Timer(true)//指定为守护线程
//Timer("name");//给定时器起名字
//Timer("name",true);//给定时器起个名字，并且设置为守护线程
Timer timer = new Timer(true);//设置为守护线程
SimoleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");//格式化时间
Date firstTime = sdf.parse("2021-2-27 03:26:00");//第一次执行时间
timer.schedule(LogTimerTask,firstTime,1000*10);//定时任务

class LogTimerTask extents TimerTask{//定时任务，继承TimerTask
    public void run(){
        //定时执行的代码块
    }
}

实现线程的第三种方式：FutureTask方式，实现Callable接口（JDK8新特性）

这种方式实现的线程可以获取线程的返回值

//创建一个未来任务类对象
//参数非常重要，需要给一个实现Callable的对象
    FutureTask task = new FutureTask(new Callable(){
    @Override
    public Object call() throws Exception(){
        System.out.println("call begin");
        Thread.sleep(1000*10);
        System.out.println("call end");
        int a = 100;
        int b = 200;
        return a+b;
    }
});
Thread t = new Thread(task);
t.start();
//主线程怎么获取t线程的返回值
Object obj = task.get();
//get线程的执行会等待task的执行完成，导致main方法阻塞
//缺点：效率较低
//优点：可以获取到线程的返回值0

关于Object类中的wait和notify方法 （生产者和消费者模式）

wait和notify是java中任何一个java对象都有的方法，因为这两个方法是Object类中自带的，而不是线程对象的方法

​ wati和notify不是谈股票线程对象调用的

wait：Object o = new Object(); o.wait();

​ 表示：让正在o对象上活动的线程进入等待状态，无期限等待，直到被唤醒为止

会让正在o对象上活动的线程进入等待状态，并且释放之前之前占用o对象的锁

o.wait()方法的调用会让当前线程（正在o对象上活动的线程）进入等待状态

notify：o.notify()唤醒被wait()等待的线程，只会通知，不会释放之前占用的o对象锁

notifyAll()：唤醒o对象上处于等待的所有线程

wait方法额notify方法建立在sunchronized线程同步的基础上

什么是生产者和消费者模式

生产线程负责生产，消费线程负责消费

生产线程和消费线程要达到均衡

wait和notify方法不是线程对象的方法，是普通java对象都有的方法

wait和notify方法建立在线程同步的基础只是。因为多线程要同时操作一个仓库，所以有线程安全问题

public static void main(String[] args){
    ArrayList al = new ArrayList();
        MyThread mt1 = new MyThread(al);
        MyThread2 mt2 = new MyThread2(al);
        mt1.start();
        mt2.start();
}

class MyThread extends Thread{
    private List list;
    public MyThread(List list){
        this.list = list;
    }
    @Override
    public void run() {
        while(true) {
            //给公共元素list加锁
            synchronized (list) {
                if (list.size() > 0) {
                    try {
                        //进入等待状态，释放list的锁
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //生产
                Object obj = new Object();
                list.add(obj);
                System.out.println(Thread.currentThread().getName()+"--->"+obj);
                //唤醒Thread2
                list.notify();
            }
        }
    }
}

class MyThread2 extends Thread{
    private List list;
    public MyThread2(List list){
        this.list = list;
    }
    @Override
    public synchronized void run() {
        while(true){
            synchronized(list) {
                if (list.size() <= 0) {
                    //解除等待状态
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //消费
                Object o = list.remove(0);
                System.out.println(Thread.currentThread().getName()+"---->"+o);
                //唤醒Thread1
                list.notify();
            }
        }
    }
}

`

class MyThread2 extends Thread{
    private List list;
    public MyThread2(List list){
        this.list = list;
    }
    @Override
    public synchronized void run() {
        while(true){
            synchronized(list) {
                if (list.size() <= 0) {
                    //解除等待状态
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //消费
                Object o = list.remove(0);
                System.out.println(Thread.currentThread().getName()+"---->"+o);
                //唤醒Thread1
                list.notify();
            }
        }
    }
}

消费和生产达成平衡一生产一消费