多线程学习总结

什么是进程？什么是线程？

程序：是为完成特定任务，用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象。
进程：是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程，有它自身的产生，存在和消亡的过程。-------生命周期
线程：进程可进一步细化为线程，是一个程序内部的一条执行路径

同步和异步&并发和并行
概念：
同步：排队执行，效率低但是安全
异步：同时执行，效率高但是数据不安全
并发：指两个或多个事件在同一个时间段内发生
并行：指两个或多个事件在同一个时刻发生

线程的调度

调度策略：
时间片：线程的调度采用时间片轮转的方式
抢占式：高优先级的线程抢占CPU
Java的调度方法：
1.对于同优先级的线程组成先进先出队列（先到先服务），使用时间片策略
2.对高优先级，使用优先调度的抢占式策略

多线程的创建方法

1：继承于Thread类：
（1）.创建一个继承于Thread类的子类
（2）.重写Thread类的run（）方法
（3）.创建Thread子类的对象
（4）.通过此对象调用start（）方法

首先

public class MyThread extends Thread {

    //run方法就是线程要执行的任务方法

    @Override
    public void run() {
        //这里的代码就是一条新的执行路径
        //这个执行路径是触发方式，不是调用run方法，而是通过thread对象的start方法来启动任务
        for (int i = 0; i < 10; i++) {
            System.out.println("锄禾日当午"+i);
        }
    }
}

然后呢

//创建一个子类对象
MyThread t = new MyThread() ;
//调用start()
t.start();

2:实现Runable接口方式
1.创建一个实现了Runable接口的类
2.实现类去实现Runnable中的抽象方法：run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类中的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start（）

下面是代码实现：
实现Runable接口的类

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //线程的任务
        for (int i = 0; i < 10; i++) {
            System.out.println("锄禾日当午"+i);
        }
    }
}

然后

实现runnable
        //1 创建一个任务对象
        MyRunnable r = new MyRunnable();
        //创建一个线程并给他一个任务
        Thread t = new Thread(r);
        //启动线程
        t.start();
        

实现Runnable与继承Thread相比有如下优势

1.通过创建任务，然后给线程分配任务的方式实现多线程，更适合多个线程同时执行任务的情况
2，可以避免单继承所带来的局限性
3，任务与线程是分离的，提高了程序的健壮性
4，后期学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程

如何设置和输出线程的名字？

public class Demo3 {
    public static void main(String[] args) {
        //如何获取线程的名称
        System.out.println(Thread.currentThread().getName());
        //两种设置线程名称的方式
        Thread t = new Thread(new MyRunnable());
        t.setName("wwww");
        t.start();
        new Thread(new MyRunnable(),"锄禾日当午").start();
        //不设置的有默认的名字
        new Thread(new MyRunnable()).start();
    }
    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

Thread.currentThread().getName()获取当前线程的名字

线程的分类

线程分为守护线程和用户线程
用户线程：当一个进程不包含任何的存活的用户线程时，进行结束
守护线程:守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。
（守护线程老舔🐶了）
守护线程的设置
调用setDaemon（）方法，传入true值，因为默认是false，然后这个线程就被设置成了守护线程。

线程的生命周期

线程生命周期的阶段	描述
新建	当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪	处于新建状态的线程被start后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
运行	当就绪的线程被调度并获得CPU资源时，便进入运行状态，run方法定义了线程的操作和功能
阻塞	在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时终止自己的执行，进入阻塞状态
死亡	线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

（梦回操作系统）

线程安全

含义 ：多个线程对同一个共享数据进行操作时，线程没来得及更新共享数据，从而导致另外线程没得到最新的数据，从而产生线程安全问题。

如课上的例子，多个线程执行卖票操作时，出现了票数余额为负数的情况，原因是在票数还没有自减的时候，其他进程加入卖掉了票。
如何解决：当一个线程在操作ticket时，其他线程不能参与进来，直到此线程的生命周期结束
在java中，我们通过同步机制，来解决线程的安全问题。

方法一：同步代码块
Synchronized（同步监视器）{
//需要被同步的代码
}
需要共享数据的代码就被视为需要被同步的代码
同步监视器（俗称：锁）：任何一个的对象都可以充当锁。（但是为了可读性一般设置英文成lock）当锁住以后只能有一个线程能进去（要求:多个线程必须要共用同一把锁，比如火车上的厕所，同一个标志表示有人）

public class Demo8 {
    public static void main(String[] args) {
        Object o = new Object();
        //线程不安全
        //解决方案1  同步代码块
        //格式：synchronized（锁对象）{
        //
        //
        //      }
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        private Object o = new Object();
        @Override
        public void run() {
            //Object o = new Object();    //这里不是同一把锁，所以锁不住
                while (true) {
                    synchronized (o) {
                        if (count > 0) {
                         //卖票
                            System.out.println("正在准备卖票");
                            try {
                            Thread.sleep(1000);
                            } catch (InterruptedException e) {
                            e.printStackTrace();
                            }
                            count--;
                            System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                        }else {
                            break;
                        }

                }
            }
        }
    }
}

方法二 :使用同步方法，对方法进行synchronized关键字修饰
将同步代码块提取出来成为一个方法，用synchronized关键字修饰此方法。
对于runnable接口实现多线程，只需要将同步方法用synchronized修饰
而对于继承自Thread方式，需要将同步方法用static和synchronized修饰

//线程同步synchronized

public class Demo9 {
    public static void main(String[] args) {
        Object o = new Object();
        //线程不安全
        //解决方案2  同步方法
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        @Override
        public void run() {

            while (true) {
                boolean flag = sale();
                if(!flag){
                    break;
                }
            }
        }
        public synchronized boolean sale(){
            if (count > 0) {
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                return true;
            }
                return false;

        }
    }
}

方法三 ：显示锁lock，创建一个锁对象，参数为true表示公平锁，默认是false 不是公平锁
private Lock l = new ReentrantLock(true);
在需要被同步的代码前痛哟锁对象调用lock（）方法上锁，在其后用unlock（）方法解锁。

//同步代码块和同步方法都属于隐式锁
//线程同步lock

public class Demo10 {
    public static void main(String[] args) {
        Object o = new Object();
        //线程不安全
        //解决方案1   显示锁  Lock  子类 ReentrantLock

        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        //参数为true表示公平锁    默认是false 不是公平锁
        private Lock l = new ReentrantLock(true);
        @Override
        public void run() {
            while (true) {
                l.lock();
                    if (count > 0) {
                        //卖票
                        System.out.println("正在准备卖票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                    }else {
                        break;
                    }
                    l.unlock();
            }
        }
    }
}

注意：lock需要手动解锁，看起来更为灵活（偷懒）

判断线程是否有安全问题，以及如何解决：

1.先判断是否多线程
2.再判断是否有共享数据
3.是否并发的对共享数据进行操作
4.选择上述三种方法解决线程安全问题