多线程技术

xiri_

已于 2023-06-05 15:33:40 修改

阅读量469

点赞数 1

分类专栏： Java开发零散知识文章标签：多线程 java

于 2020-08-13 22:49:28 首次发布

本文链接：https://blog.csdn.net/xiri_/article/details/107993519

版权

Java开发零散知识专栏收录该内容

15 篇文章 1 订阅

订阅专栏

多线程技术概述

线程与进程

进程

是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程

是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程。每个线程都拥有自己的栈空间，共用一份堆内存，（每个线程都在自己的栈空间中运行）
由一个线程所调用的方法也会执行在这个线程中。
线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程。

总结：

线程是进程的具体实现方式，每个进程最少包含一个线程。

线程调度

分时调度

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

总结：

Java中使用的为抢占式调度，哪个线程抢到了就优先执行哪个，在使用不公平锁的情况下，大多数时候第一个抢占到资源的线程后续抢到资源的机率更高

同步和异步

同步: 排队执行 , 效率低但是安全.（多个线程排队执行，一次只执行一个线程）

异步: 同时执行 , 效率高但是数据不安全.（多个线程同时进行，一个时刻执行多个线程）

并发与并行

并发：指两个或多个事件在同一个时间段内发生。

并行：指两个或多个事件在同一时刻发生（同时发生）。

线程的创建方式

线程的创建方式共三种：

实现Runnable接口
继承Thread方法
实现Callable接口

三种创建方法的区别

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

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

Runnable 与 Callable的相同点

都是接口
都可以编写多线程程序
都采用Thread.start()启动线程

Runnable 与 Callable的不同点

Runnable没有返回值；Callable可以返回执行结果
Callable接口的call()允许抛出异常；Runnable的run()不能抛出

Callable获取返回值

Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

三种创建方法的实现

Thread

//继承Thread类，重写run方法
public class MyThread extends Thread {
    //run方法就是线程要执行的任务方法
    @Override
    public void run() {
        //这里的代码就是一条新的执行路径
        //这个执行路径是触发方式，不是调用run方法，而是通过thread对象的start方法来启动任务
        for (int i = 0; i < 10; i++) {
            System.out.println("继承Thread类"+i);
        }
    }
}

//调用MyThread方法，创建线程
public class Demo1 {
    public static void main(String[] args) {

        MyThread m = new MyThread();
        m.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("展示"+i);
        }
    }
}

Thread 也可以直接采用匿名内部类的形式呈现

public class ThreadDemo {
    public static void main(String[] args) {
        //此方法还是继承了Thread方法，为匿名内部类
    	new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("继承Thread类"+i);
                }
            }
        }.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("展示"+i);
        }
    }
}

Runnable

//实现接口类：
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //线程的任务
        for (int i = 0; i < 10; i++) {
            System.out.println("实现Runnable接口"+i);
        }
    }
}

//调用方法Runnable
public class Demo1 {
    public static void main(String[] args) {
        //实现runnable
        //1 创建一个任务对象
        MyRunnable r = new MyRunnable();
        //创建一个线程并给他一个任务
        Thread t = new Thread(r);
        //启动线程
        t.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("展示"+i);
        }
    }
}

Callable

//Callable的使用步骤
1. 编写类实现Callable接口 , 实现call方法 
	class XXX implements Callable<T> { 
		@Override 
		public <T> call() throws Exception {
        	return T; 
        } 
    }
        
2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象 FutureTask<Integer> 			future = new FutureTask<>(callable); 

3. 通过Thread,启动线程 new Thread(future).start();

线程的使用

线程名称的获取

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

当调用的类中无main方法时，所获取的线程名称为默认名称

默认名称：Thread-i ，线程初次创建，i 为0，每多创建一次该线程，i++

public class Demo3 {
    public static void main(String[] args) {
        //如何获取线程的名称
    	//Thread.currentThread().getName() 获取当前线程名称：main
        System.out.println(Thread.currentThread().getName());
        //两种设置线程名称的方式
        Thread t = new Thread(new MyRunnable());
        //第一种方式，使用  线程名.setName（） 形式给线程命名
        t.setName("wwww");  //给线程设置名称
        t.start();  //运行线程
        //第二种形式，匿名内部类，new Thread(new MyRunnable(),线程名).start();
        new Thread(new MyRunnable(),"锄禾日当午").start();
        //不设置的有默认的名字，线程默认名为Thread-i，i从0开始，每多创建一次i++
        new Thread(new MyRunnable()).start();
    }
    static class MyRunnable implements Runnable{

        @Override
        public void run() {
        	//MyRunnable类中无main方法，所以获取线程名称为默认名称
        	//默认名称：Thread-i ， i初始值为0，每多创建一次该线程，i++
            System.out.println(Thread.currentThread().getName());
        }
    }
}

线程休眠

线程的休眠采用sleep方法，休眠的单位为毫秒

public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        //线程的休眠
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
            Thread.sleep(1000);     //1000毫秒，即1秒
        }
    }
}

线程中断

在多个线程在一个main方法中执行时，直接执行线程，会造成线程一直抢占资源的情况

这种情况下，当我们要某个线程结束后，另外一个线程也随之结束，可以采用线程中断的方式

线程中断的格式为：线程名.interrupt();

public class Demo5 {
    public static void main(String[] args) {
        //线程中断
        //一个线程是一个独立的执行路径，它是否结束应该由其自身决定
    	//MyRunnable线程和main线程无法确定先后顺序，由线程抢占资源输出
        Thread t1 = new Thread(new MyRunnable());
        t1.start();
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //给线程t1添加中断标记
        t1.interrupt();
    }

    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+":"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //e.printStackTrace();
                    System.out.println("发现了中断标记，线程自杀");
                    return;  //return就表示结束该线程
                }
            }
        }
    }
}

//运行结果如下：
main:0
Thread-0:0
main:1
Thread-0:1
main:2
Thread-0:2
main:3
Thread-0:3
main:4
Thread-0:4
Thread-0:5
发现了中断标记，线程自杀

此时我们发现一个问题，当main线程结束后，MyRunnable多执行了一次，是因为当main线程结束的时候，main方法还未结束，此时MyRunnable线程多执行了一次后执行的中断，故线程MyRunnable比main线程多执行了一次。

线程分类

线程分为守护线程和用户线程

用户线程：当一个进程不包含任何的存活的用户线程时，进行结束。
守护线程：守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。

守护线程的格式：线程名.setDaemon（ true|false ）；

public class Demo6 {
    public static void main(String[] args) {
        //线程分为守护线程和用户线程
        //用户线程：当一个进程不包含任何的存活的用户线程时，进行结束
        //守护线程:守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。
        Thread t1 = new Thread(new MyRunnable());
        //设置t1为守护线程，当main线程走到5时，由于main方法需要结束，所以会多运行一次t1线程
        t1.setDaemon(true);
        t1.start();
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+":"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

//运行结果
main:0
Thread-0:0
main:1
Thread-0:1
Thread-0:2
main:2
main:3
Thread-0:3
main:4
Thread-0:4
Thread-0:5

//设置t1为守护线程，当main线程走到5时，由于main方法需要结束，所以会多运行一次t1线程

线程安全问题

线程不安全即指，当我们在使用多个线程的时候，有时候多个线程在符合某个条件的情况下进入同一个代码块，然后输出的结果不符合实际程序设定的结果。

以下为一个线程不安全的例子：

public class Demo7 {
    public static void main(String[] args) {
        //线程不安全
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
        
        /**		线程不安全
         * 有可能出现count为负数的情况，因为当三个线程都在进行中，
         * 有可能三个进程在count小于3的时候都进入代码块，进行三次count--，最后输出就会存在负数
         */
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        @Override
        public void run() {
            while (count>0){
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("卖票结束,余票："+count);
            }
        }
    }
}

线程不安全的解决方案

解决方案一

同步代码块 （隐式锁）

使用同步代码块的方式，多个线程需要进行排队，每次只允许一个线程进行用此方法，并且第一次抢到资源的线程重复抢到资源的机率最高，因为资源刚释放，该线程也刚好可以进行抢夺资源，正所谓 ”来得早不如来得巧“

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();  
        //该对象必须创建在run方法外，当run中使用synchronized进行同步时，多个线程采用一把锁
        @Override
        public void run() {
            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修饰

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;
                }
            }
        }
        //同步方法的方式就是在方法类型前加上synchronized修饰
        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（显式锁）

public class Demo10 {
    public static void main(String[] args) {
        Object o = new Object();
        //线程不安全
        //解决方案3   显式锁  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();
            }
        }
    }
}

公平锁和不公平锁

在显式锁中，我们引进了公平锁和不公平锁的概念，接下来跟大家讲一下这两个锁的使用。

上面列出的三种都属于不公平锁，公平锁的的格式在显式锁的基础上创建，例：

//参数为true表示公平锁    默认是false 不是公平锁
private Lock l = new ReentrantLock(true);

线程死锁

线程死锁就是两个线程相互调用彼此的方法，刚好等待处于两个都需要对方释放资源，此时就会产生线程死锁，不线程之间相互调用，卡住了。
规避线程死锁的方式，就是当一个线程中已经有锁的情况下，该线程的方法中就不要调用另外一个含有锁的方法。

public class Demo11 {
    public static void main(String[] args) {
        //线程死锁
        Culprit c = new Culprit();
        Police p = new Police();
        new MyThread(c,p).start();  //执行MyThread中的run方法，即p.say(c)
        c.say(p);
    }

    static class MyThread extends Thread{
        private Culprit c;
        private Police p;
        MyThread(Culprit c,Police p){
            this.c = c;
            this.p = p;
        }

        @Override
        public void run() {
            p.say(c);
        }
    }
    
    static class Culprit{
        public synchronized void say(Police p){
            System.out.println("罪犯：你放了我，我放了人质");
            p.fun();
        }
        public synchronized void fun(){
            System.out.println("罪犯被放了，罪犯也放了人质");
        }
    }
    
    static class Police{
        public synchronized void say(Culprit c){
            System.out.println("警察：你放了人质，我放了你");
            c.fun();
        }
        public synchronized void fun(){
            System.out.println("警察救了人质，但是罪犯跑了");
        }
    }
}

线程等待

等待（暂时休眠）：使用wait方法

唤醒：使用notify和notifyAll方法

代码中等待的使用只要在静态food类中。

public class Demo12 {
    public static void main(String[] args) {
        //多线程通信    生产者与消费者问题
        Food f = new Food();
        new Cook(f).start();
        new Waiter(f).start();
    }
    //厨师
    static class Cook extends Thread{
        private Food f;

        public Cook(Food f) {
            this.f = f;
        }

        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                if(i%2==0){
                    f.setNameAndTaste("老干妈小米粥","香辣味");
                }else {
                    f.setNameAndTaste("煎饼果子","甜辣味");
                }
            }
        }
    }
    //服务员
    static class Waiter extends Thread{
        private Food f;

        public Waiter(Food f) {
            this.f = f;
        }

        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                f.get();
            }
        }
    }
    //食物
    static class Food{
        private String name;
        private String taste;
        //true表示可以生产
        boolean flag = true;
        public synchronized void setNameAndTaste(String name,String taste){
            if(flag){
                this.name = name;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.taste = taste;
                flag = false;
                this.notifyAll();  //唤醒所有线程
                try {
                    this.wait();  //将自身线程设置为等待状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
        public synchronized void get(){
            if(!flag){
                System.out.println("服务员端走的菜的名称是："+name+",味道是："+taste);
                flag = true;
                this.notifyAll();	//唤醒所有线程
                try {
                    this.wait();	//将自身线程设置为等待状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

线程的状态

线程共有6种状态，如图所示：
在这里插入图片描述

线程状态之间的关系：
在这里插入图片描述

线程池 Executors

概述：

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

线程池的好处：

降低资源消耗。
提高响应速度。
提高线程的可管理性。

线程池的分类：

缓存线程池

	/**
	* 缓存线程池. 
	* (长度无限制) 
	* 执行流程: 
	* 1. 判断线程池是否存在空闲线程 
	* 2. 存在则使用 
	* 3. 不存在,则创建线程 并放入线程池, 然后使用 
	*/ 
ExecutorService service = Executors.newCachedThreadPool(); 
	//向线程池中 加入 新的任务 
service.execute(new Runnable() { 
	@Override 
	public void run() { 
		System.out.println("线程的名称:"+Thread.currentThread().getName()); 
	} 
}); 
service.execute(new Runnable() { 
	@Override 
	public void run() { 
		System.out.println("线程的名称:"+Thread.currentThread().getName()); 
	} 
}); 
service.execute(new Runnable() { 
	@Override 
	public void run() { 
		System.out.println("线程的名称:"+Thread.currentThread().getName()); 
	} 	
});

定长线程池

	/*** 定长线程池. 
	* (长度是指定的数值) 
	* 执行流程:
	* 1. 判断线程池是否存在空闲线程 
	* 2. 存在则使用 
	* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用 
	* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程 
	*/ 
ExecutorService service = Executors.newFixedThreadPool(2); service.execute(new Runnable() { 
	@Override 
	public void run() { 
		System.out.println("线程的名称:"+Thread.currentThread().getName()); 
	} 
}); 
service.execute(new Runnable() { 
	@Override 
	public void run() { 
		System.out.println("线程的名称:"+Thread.currentThread().getName()); 
	}
});

单线程线程池

效果与定长线程池 创建时传入数值1 效果一致. 
	/**
	* 单线程线程池. 
	* 执行流程: 
	* 1. 判断线程池 的那个线程 是否空闲 
	* 2. 空闲则使用 
	* 3. 不空闲,则等待 池中的单个线程空闲后 使用 
	*/ 
ExecutorService service = Executors.newSingleThreadExecutor(); service.execute(new Runnable() { 
	@Override 
	public void run() { 
		System.out.println("线程的名称:"+Thread.currentThread().getName()); 
	} 
}); 
service.execute(new Runnable() { 
	@Override 
	public void run() { 
		System.out.println("线程的名称:"+Thread.currentThread().getName()); 
	} 
});

周期性任务定长线程池

public static void main(String[] args) { 
	/**
	* 周期任务 定长线程池. 
	* 执行流程: 
	* 1. 判断线程池是否存在空闲线程 
	* 2. 存在则使用 
	* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用 
	* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程 
	*
	* 周期性任务执行时: 
	* 定时执行, 当某个时机触发时, 自动执行某任务 .
	*/ 
	ScheduledExecutorService service = Executors.newScheduledThreadPool(2); 	/**
	* 定时执行 
	* 参数1. runnable类型的任务 
	* 参数2. 时长数字 
	* 参数3. 时长数字的单位 
	*/ 
	/*service.schedule(new Runnable() { 
		@Override 
		public void run() { 
			System.out.println("俩人相视一笑~ 嘿嘿嘿"); 
		} 
	},5,TimeUnit.SECONDS); */
	/**
	* 周期执行 
	* 参数1. runnable类型的任务 
	* 参数2. 时长数字(延迟执行的时长) 
	* 参数3. 周期时长(每次执行的间隔时间) 
	* 参数4. 时长数字的单位 */ 
	service.scheduleAtFixedRate(new Runnable() { 
		@Override 
		public void run() { 
			System.out.println("俩人相视一笑~ 嘿嘿嘿"); 
		} 
	},5,2,TimeUnit.SECONDS); 
}

lambda表达式

public class Demo17 {
    /*
     * lambda表达式
     *  函数式编程思想
     *  面向对象：	创建对象调用方法解决问题
     */
    public static void main(String[] args) {
        //冗余的Runnable编写方式
       /* Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("锄禾日当午");
            }
        });
        t.start();*/
		
		//当所使用的线程只需要run方法中只有一个执行语句，可用以下方法
        Thread t = new Thread(() -> System.out.println("锄禾日当午"));
        
        //当需要调用方法的时候，可以做如下操作
        Thread t1 = new Thread(() -> {//大括号中放置方法内容
        	System.out.println("锄禾日当午");});
        t.start();
        t1.start();
    }
}