多线程解析

多线程

并发与并行

​ 并发：同一段时间发生多件事情

​ 并行：多件事情在同一时刻

进程与线程

​ 进程：软件启动时，操作系统会给它分配一个内存载体来运行程序，这个运行的程序就是进程。它具有独立的功能。

​ 线程：是执行程序的一条线路，一个程序可以有一个线程，也可以有多个线程。

线程调度

​ 操作系统是线程的调度者。

平均分配（分时调度）

​ 所有线程轮流使用cpu资源。

抢占式调度

​ 优先让优先级高的线程使用cpu，优先级相同的随机选择一个使用cpu；

主线程

​ 首先执行的线程叫主线程，一般是执行main方法的那个线程

多线程

多线程实现的两种方式：

1.定义一个类，继承Thread类

public class Test extends Thread{
    //继承父类Thread并重写run方法
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            System.out.println("子线程打印" + i);
            System.out.println("子线程名字为"+currentThread().getName());
        }
    }

    public static void main(String[] args) {
        System.out.println("主线程开始执行");
        for (int i =0;i<10;i++){
            System.out.println("主线程开始打印" + i);
            System.out.println("主线程名字为"+currentThread().getName());
        }
        //创建线程类的对象
        Test t = new Test();
        t.start();
    }
}

可以通过currentThread().getName()获取线程名字。

可以通过给构造方法（在子类的构造方法中调用父类的构造方法）传参给线程起名字。

可以调用Thread.sleep(long millis);使当前线程睡眠多少毫秒。

2.定义一个类，实现Runnable接口

public class Test implements Runnable{
    //定义一个类,实现Runnable对象
    //重写run方法
    @Override
    public void run() {
        for (int i =0;i<10;i++){
            System.out.println("子线程打印"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        //创建实现类的对象
        Test test= new Test();
        //创建Thread类的对象,将上面的线程类传入
        Thread t = new Thread(test);
        t.start();
    }
}

可以在创建Thread对象时给线程起名字。Thread t = new Thread(Runnable r ,String name);

Thread和Runnable的区别：

​ 1.Thread方式

​ 定义一个子类继承Therad类，这个类不能继承其他父类，扩展性遭到限制。

​ 2.Runnable方式

​ 定义一个实现类实现Runnable接口，还可以实现其他接口和继承其他父类，扩展性强。

​ 把任务的定义和线程类的创建进行分离，更符合面向对象中的解耦思想。

匿名内部类实现线程

​ 1.继承实现

 System.out.println("主线程开始执行了");
        //创建Thread类的匿名内部类的对象
        Thread thread = new Thread() {
            @Override
            public void run() {
                for (int i=0;i<10;i++){
                    System.out.println("子线程打印"+ i);
                }
            }
        };
        thread.start();

​ 2.接口实现

System.out.println("主线程开始执行了");
        //创建Thread类的匿名内部类的对象
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<10;i++){
                    System.out.println("子线程打印"+i);
                }
            }
        });
        t.start();

线程安全

多个线程访问一个数据，在访问的过程中修改数据就可能出现线程安全的问题。

线程不安全的代码：

public class Ticket implements Runnable {
    //用来记录剩余的票数
    int ticket = 100;
    @Override
    public void run() {
        while(true){
            if(ticket>0){
                System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                ticket--;
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }


        }
    }
    public static void main(String[] args) {
        //创建Ticket任务
        Ticket t = new Ticket();
        //创建三个子线程
        Thread tt1 = new Thread(t,"窗口1");
        Thread tt2 = new Thread(t,"窗口1");
        Thread tt3 = new Thread(t,"窗口1");
        //开启子线程
        tt1.start();
        tt2.start();
        tt3.start();
    }
}

解决线程不安全的三种方式

1.同步代码块

synchronized（锁对象）{

​ 可能出现线程安全的代码

}

synchronized是同步的关键字，锁对象可以是任意一个对象（但需要保证多个线程用的是同一个对象），作用是锁住这一段代码。

public void run() {
        while(true){
            //使用同步代码块
            synchronized (obj){
                if(ticket>0){
                    System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                    ticket--;
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

2.同步方法

在方法前面加synchronized关键字

	//定义一个同步方法
    private (static) synchronized void method() {
        if(ticket>0){
            System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
            ticket--;
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

保证这个方法同一时间只能被一个线程访问，在这个方法中也有一个锁对象this。可以在方法中加入static关键字

静态同步锁锁的是.class对象

3.Lock锁

Lock是一个接口，调用的是它的接口。

		//创建Lock锁对象
        Lock lock = new ReentrantLock();
        while(true){
            //上锁
            lock.lock();
            if(ticket>0){
                System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                ticket--;
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //关锁
            lock.unlock();

线程的状态

新建 --> 就绪 —> 运行 —>阻塞 —> 死亡

​ | |

​ |———————————|

​ 线程苏醒后进入就绪状态或死亡状态