多线程

Posted 2021-06-12 Un1verse

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了多线程相关的知识，希望对你有一定的参考价值。

1 Process与Thread

程序是指令和数据的有序集合，其本身没任何运行的含义，是一个静态的概念
而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位

注意：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。

本章核心概念：

线程就是独立的执行路径
在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程
main()称为主线程，为系统的入口，用于执行整个程序
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的
对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
线程会带来额外的开销，如cpu的调度时间，并发控制开销
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

2 线程创建

三种创建方式：

1、继承Thread类（重点）

2、实现Runnable接口（重点）

3、实现Callable接口（了解）

2.1 继承Thread类

public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("r"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程
        //注意：线程开启不一定立即执行，由cpu调度执行

        //创建一个线程对象，调用start()方法开启线程
        TestThread1 testThread1 = new TestThread1();
        testThread1.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("m"+i);
        }
    }
}

2.2 实现Runnable接口

//实现Runnable接口，重写run()方法，执行线程需要丢入Runnable接口实现类
public class TestThread2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("r"+i);
        }
    }

    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        TestThread2 testThread2 = new TestThread2();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        Thread thread = new Thread(testThread2);

        thread.start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("m"+i);
        }
    }
}

前两种方法的区别：

2.3 案例

抢火车票

public class TestThread3 implements Runnable {
    //多个线程同时操作同一个对象
    //买火车票的例子

    //发现问题：多个线程同时操作同一个资源的情况，线程不安全，数据紊乱

    //票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true){
            if (ticketNums<=0){
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"张票");
        }
    }

    public static void main(String[] args) {
        TestThread3 ticket = new TestThread3();

        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛").start();
    }
}

龟兔赛跑

package Multithreading;

//模拟龟兔赛跑
public class Race implements Runnable{

    //胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {

            //模拟兔子休息
            if (Thread.currentThread().getName().equals("兔子") && i%10==0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            boolean flag = gameOver(i);
            if (flag){
                break;
            }

            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
        }
    }
    private boolean gameOver(int steps){
        //判断是否有胜利者
        if (winner!=null){
            return true;
        }
        if (steps==100){
            winner = Thread.currentThread().getName();
            System.out.println("winner is "+winner);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

2.4 实现Callable接口

3 Lamda表达式

λ希腊字母表中排序第十一位的字母

避免匿名内部类定义过多

其实质属于函数式编程的概念

函数式接口 Functional Interface:

任何接口，如果只包含唯一一个抽象方法，他就是一个函数式接口
public interface Runnable{public abstract void run()}
对于函数式接口，我们可以通过lambda表达式来创建该接口的对象

package Multithreading;

public class TestLambda1 {

    //3.静态内部类
    static class Like2 implements ILike{

        @Override
        public void lambda() {
            System.out.println("I like lambda2");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        like = new Like2();
        like.lambda();

        //4.局部内部类
        class Like3 implements ILike{

            @Override
            public void lambda() {
                System.out.println("I like lambda3");
            }
        }

        like = new Like3();
        like.lambda();

        //5.匿名内部类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I like lambda4");
            }
        };
        like.lambda();

        //6.Lambda表达式
        like = () -> {
            System.out.println("I like lambda5");
        };
        like.lambda();

    }


}

//1.定义一个函数式接口
interface ILike{
    void lambda();
        }

//2.实现类
class Like implements ILike{

    @Override
    public void lambda() {
        System.out.println("I like lambda1");
    }
}

package Multithreading;

public class TestLambda2 {
    public static void main(String[] args) {
        //Lambda简化
        ILove love = (int a)->{
            System.out.println("I love you "+a);
        };

        //简化1.参数类型
        love = (a)->{
            System.out.println("I love you "+a);
        };

        //简化2.简化括号
        love = a->{
            System.out.println("I love you "+a);
        };

        //简化3.去掉花括号(只有一行代码的情况下才能使用)
        love = a-> System.out.println("I love you "+a);


        love.love(1314);
    }
}

//函数式接口
interface ILove{
    void love(int a);
}

4 静态代理模式

package Multithreading;

//静态代理模式总结：
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色

public class StaticProxy {
    public static void main(String[] args) {

        new Thread(()-> System.out.println("I love you")).start();
        new WeddingCompany(new You()).HappyMarry();
    }
}
interface Marry{
    void HappyMarry();
}

class You implements Marry{

    @Override
    public void HappyMarry() {
        System.out.println("happy!");
    }
}

//代理
class WeddingCompany implements Marry{

    private Marry targe;

    public WeddingCompany(Marry targe){
        this.targe = targe;
    }

    @Override
    public void HappyMarry() {
        before();
        this.targe.HappyMarry();//真实对象
        after();
    }

    private void before(){
        System.out.println("结婚前，布置现场");
    }

    private void after(){
        System.out.println("结婚后，收尾款");
    }

}

5 线程状态

5.1 线程停止

package Multithreading;

//测试stop
//1.建议线程正常停止-->利用次数，不建议死循环
//2.建议使用标志位-->设置一个标志位
//3.不要使用stop或destroy等过时或jdk不建议使用的方法
public class TestStop implements Runnable{

    //1.设置一个标志位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run...Thread "+i++);
        }
    }

    //2.设置一个公开的方法停止线程，转换标志位
    public void stop() {
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main "+i);
            if (i==900){
                //调用stop方法切换标志位使线程停止
                testStop.stop();
                System.out.println("线程停止");
            }
        }
    }
}

5.2 线程休眠 Sleep

package Multithreading;

import java.text.SimpleDateFormat;
import java.util.Date;


public class TestSleep2 {

    public static void main(String[] args) {
        //打印当前时间
        Date date = new Date(System.currentTimeMillis());

        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
                date = new Date(System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //模拟倒计时
    public static void count() throws InterruptedException {
        int num = 10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }
    }
}

5.3 线程礼让 Yield

礼让线程，让当前正在执行的线程暂停，但不阻塞
将线程从运行状态转为就绪状态
让CPU重新调度，礼让不一定成功，看cpu“心情”

package Multithreading;

public class TestYield {

    public static void main(String[] args) {
        MyYield myYield = new MyYield();

        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }

}

class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

5.4 Join合并线程

待此线程执行完毕后，再执行其他线程，其他线程阻塞

可想象成插队

package Multithreading;

public class TestJoin implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.println("线程vip来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //启动线程
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        //主线程
        for (int i = 0; i < 1000; i++) {
            if (i==200){
                thread.join();//插队
            }
            System.out.println("main"+i);
        }

    }
}

5.5 线程状态观测

package Multithreading;

public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("-------------");
        });
        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);//NEW

        //观察启动后
        thread.start();//启动线程
        state = thread.getState();
        System.out.println(state);//Runnable

        while (state != Thread.State.TERMINATED){//只要线程不终止，就一直输出状态
            Thread.sleep(100);
            state = thread.getState();
            System.out.println(state);
        }
    }
}

6 线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行

package Multithreading;

public class TestPriority {
    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        MyPriority myPriority = new MyPriority();

        Thread thread1 = new Thread(myPriority);
        Thread thread2 = new Thread(myPriority);
        Thread thread3 = new Thread(myPriority);
        Thread thread4 = new Thread(myPriority);
        Thread thread5 = new Thread(myPriority);
        Thread thread6 = new Thread(myPriority);

        //先设置优先级，再启动
        thread1.start();

        thread2.setPriority(1);
        thread2.start();

        thread3.setPriority(4);
        thread3.start();

        thread4.setPriority(Thread.MAX_PRIORITY);//10
        thread4.start();

        thread5.setPriority(-1);
        thread5.start();

        thread6.setPriority(11);
        thread6.start();
    }
}
class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

优先级低只是意味着获得调度的概率低，主要看cpu的调度

7 守护线程

线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕

package Multithreading;

public class TestDaemon {

    public static void main(String[] args) {
        God god = new God();
        People people = new People();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认是false表示用户线程，正常的线程都是用户线程

        thread.start();//上帝守护线程启动

        new Thread(people).start();//用户线程启动
    }
}

class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("God bless you");
        }
    }
}


class People implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("活着");
        }
        System.out.println("hello World");
    }
}

8 线程同步

并发:同一个对象被多个线程同时操作

线程同步其实是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用

线程同步形成条件：队列+锁

以上是关于多线程的主要内容，如果未能解决你的问题，请参考以下文章

线程学习知识点总结

多个请求是多线程吗

python小白学习记录多线程爬取ts片段

多线程编程

python多线程