黑马程序员--多线程-CSDN博客

本文链接：https://blog.csdn.net/a1659177869/article/details/44682213

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
想要了解多线程，首先就要弄明白进程和线程的概念。

进程：正在执行中的程序，每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元.
线程：就是进程中的一个独立的控制单元,线程在控制着进程的执行，一个进程中至少有一个线程。

线程创建的两种方式：

1.继承Thread类，覆盖run()方法
步骤：(1).定义类继承Thread类
     (2).复写Thread类中的run()方法 目的：将自定义代码存储在run方法中，让线程运行。
     (3).调用该类的start()方法
2.实现Runnable接口，实现run()方法
步骤：(1). 定义类实现Runnable接口
     (2). 实现Runnable接口中的run()方法,将线程要运行的代码存放在该run方法中
     (3). 将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数创建Thread类对象
    为什么要将Runnable接口的子类对象传递给Thread的构造函数？
    因为，自定义的run方法所属的对象是Runnable接口的子类对象,所以要让线程去指定制定对象的run方法。就必须明确该run方法所属的对象
     (4). 调用Thread类的start()方法开启并调用Runnable接口子类的run方法

两种创建方式的区别：

实现方式避免了单继承的局限性。
在定义线程时，建议使用实现方式。
当一个类继承了Thread之后，该类就不能去继承其他类了。
继承Thread类：线程代码存放在Thread子类run方法中。
实现Runnable接口：线程代码存放在接口子类的run方法中。

为什么要覆盖run方法呢？

Thread类用于描述线程,该类就定义了一个功能，用于存储线程要运行的代码该存储功能就是run方法,也就是说Thread类中的run方法，用于存储要运行的代码。

start()与run()的区别：

start()作用是启动线程，调用run()方法。
run()方法仅仅是普通的调用，程序不能多线程执行。

线程的5种状态：

1.  建立 start方法；
2.  运行 具备运行资格，同时具备执行权
3.  消亡 stop()方法 或者run方法运行完
4.  临时阻塞 具备运行资格，但不具备执行权
5.  冻结 sleep（）方法,wait()方法，线程放弃执行权，也放弃执行资格

这里写图片描述

多线程的安全问题：
问题原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没执行完，另一线程参与进来，导致了共享数据的错误。

如何找到多线程的安全问题：
1. 明确那些代码是多线程运行代码
2. 明确共享数据
3. 明确多线程运行代码中那些语句操作共享数据

解决方案;
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

java对于多线程的安全问题提供了专门的解决方案，即：同步代码块。

synchronized(对象)
{
    需要被同步的代码
}

对象如同锁(监视器)，持有锁的线程可以在同步中执行没有持有锁的线程即使是获取了CPU的使用权也进不去。因为没有锁。
同步的典型案例：火车上的卫生间

同步的前提：
1. 必须是有两个或两个以上的线程。
2. 必须是多个线程使用的同一个锁。
同步解决了多线程的安全问题，但是因为多个线程需要判断多个锁，较为耗费资源。
同步的一个示例: 卖票的例子。

class Ticket implements Runnable
{   private int tick=200;
    private Object obj=new Object();
    public void run()
    {
        while(true)
        {   synchronized(obj)
            {
                if(tick>0)
                {
                    try
                    {
                        Thread.sleep(5);
                        System.out.println(Thread.currentThread().getName()+"__sale:"+tick--);
                    }
                    catch (Exception e)
                    {
                    }
                }
            }
            if(tick<=0)
                    return;
        }
    }
}

class TicketDemo 
{
    public static void main(String[] args) 
    {
        Ticket t=new Ticket();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        Thread t4=new Thread(t);
        t1.start();
        t2.start();
        t3.start();
        t4.start(); 
    }
}

多线程共享数据可以不通过静态，一个类通过实现Runnable接口就具备了可被多线程执行的功能，只需要创建一个对象，将这个对象作为实参，传递给多个Thread类的构造函数，就可以开启多条线程，共同操作该类的数据了。

同步函数使用的锁是this；
静态同步函数使用的锁是该类的字节码文件对象。类名.Class。

死锁：
A持有一个锁，B持有一个锁，A锁里面有一部分代码要到B锁里面执行，B锁里面有一部分代码要到A锁里面执行，A、B都向对方要锁而不释放自己的锁，不放自己的锁，这样就产生了死锁。死锁发生后程序不在继续向下执行。
死锁产生原因：同步里面嵌套同步。两个线程相互等待对方已被锁定的资源。
如何解决死锁呢：
这里写图片描述
可以使用一种资源排序的方法解决死锁。该技术给每个需要锁的对象指定顺序确保每个线程都按这个顺序来获取所。如图所示的死锁，在使用资源排序后，线程2必须先获取objectA上的锁，然后才能获取objectB上的锁。线程1也一样，一旦线程1获取了objectA上的锁，线程2必须等待objectA上的锁，这是线程1就能获取objectB上的锁，从而避免死锁的发生。

请写出一个死锁程序：

class DeadLock implements Runnable
{
    boolean flag=true;
    DeadLock(boolean flag){
        this.flag=flag; 
    }
    public void run(){
        if(flag){
            synchronized(MyLock.alock){
                System.out.println("if alock");
                synchronized(MyLock.block){
                    System.out.println("if block");
                }
            }
        }
        else{
            synchronized(MyLock.block){
                System.out.println("else block");
                synchronized(MyLock.alock){
                    System.out.println("else alock");
                }
            }
        }
    }
}
class MyLock{
    static Object alock=new Object();
    static Object block=new Object();
}
class Test{
    public static void main(String[] args){
        new Thread(new DeadLock(true)).start();
        new Thread(new DeadLock(false)).start();
    }
}

Thread类常用方法：
1. getName();获取名称
线程都有默认的名称Thread—编号。从0开始。
自定义线程名称：父类构造函数已经提供了带name的构造方法
子类继承只需调用父类的构造函数即可
eg:class A exteds Thread{A(String name){super(name)} public void run(){}}
2.static Thread currentThread()
返回对当前正在执行的线程对象的引用
3. interrupt();强制让线程恢复到运行状态中来，对线程的冻结状态进行清除。清除冻结状态后可以操作标记结束线程。
4.setDeamon(true);守护线程
在线程启动前调用
将线程设置为守护线程或用户线程或后台线程
当前台线程结束后，后台线程自动结束。
5.join();抢夺CPU的执行权
当A线程执行到了B线程的join方法时，A线程就会等待，等B线程执行完A才执行。join方法用来根据条件加入临时线程
eg:

main(){         //main方法
    Demo d=new Demo();
    Thread t1=new Thread(d);
    Thread t2=new Thread(d);
    //t1.setDeamon(true); //将线程t1设置为守护线程，当线程t2与主线程执行完毕，t1自动结束
    t1.start();
    //t1.join();        //CPU运行到此处，主线程放弃执行权，等待t1执行完后继续执行
    t2.start();
    //t1.join()；    //如果join在此处，此时t1,t2都已开启，但是main方法会放弃执行权，
                    //线程t1与t2执行，主线程等t1执行完后才开始继续执行，与t2无关
    for (int i=0; i<200; i++)
    {
        System.out.println("main..."+i);
    }
}

6.setPriority() 设置优先级优先级：表示抢资源的频率
优先级只有10个等级 1-10
Thread.MAX_PRIORITY 10
Thread.MIN_PRIORITY 1
Thread.NORM_PRIORITY 5
所有线程默认优先级是5
7.static void yield();临时停止正在执行的线程去执行其他线程。
可以稍微减少线程的运行，可以达到多个线程平均运行的效果。