多线程

陆源东

于 2021-04-23 01:11:37 发布

阅读量110

点赞数

分类专栏： Java高级

本文链接：https://blog.csdn.net/m0_53509974/article/details/116036541

版权

Java高级专栏收录该内容

5 篇文章 0 订阅

订阅专栏

主线程与子线程

在这里插入图片描述

进程与线程

进程是执行程序的一次执行过程，是一个动态的概念，是系统分配资源的单位
一个进程可以包含若干个线程，线程是CPU调度和执行的单位

模拟多线程

真实多线程是指多个CPU，而实际上程序中的多线程是用一个CPU模拟多线程，只不过切换的很快，模拟了同时进行的效果。

线程创建

1.继承Thread类
Thread实现了Runnable接口
1.自定义线程类继承Thread
2.重写run（）方法，编写线程执行体
3.创建线程对象，调用start（）方法启动线程
run()方法与start()方法的区别

run()方法是串行执行，先执行完run方法，再执行之后的代码
start()方法是并行执行

//使用Thread来实现一个并行下载功能
public class TestThread2 extends Thread{
    private String url;
    private String name;
    public TestThread2(String url,String name)
    {
        this.url = url;
        this.name = name;
    }
    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载的文件名为："+name);
    }
    public static void main(String args[]) {
        TestThread2 t1 = new TestThread2("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fyouimg1.c-ctrip.com%2Ftarget%2Ftg%2F035%2F063%2F726%2F3ea4031f045945e1843ae5156749d64c.jpg&refer=http%3A%2F%2Fyouimg1.c-ctrip.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1621684774&t=0abb0e977c0d8ee31f6edd72c12c1b4a","1.jpg");
        TestThread2 t2 = new TestThread2("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fyouimg1.c-ctrip.com%2Ftarget%2Ftg%2F035%2F063%2F726%2F3ea4031f045945e1843ae5156749d64c.jpg&refer=http%3A%2F%2Fyouimg1.c-ctrip.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1621684774&t=0abb0e977c0d8ee31f6edd72c12c1b4a","2.jpg");
        TestThread2 t3 = new TestThread2("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fyouimg1.c-ctrip.com%2Ftarget%2Ftg%2F035%2F063%2F726%2F3ea4031f045945e1843ae5156749d64c.jpg&refer=http%3A%2F%2Fyouimg1.c-ctrip.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1621684774&t=0abb0e977c0d8ee31f6edd72c12c1b4a","3.jpg");

        t1.start();
        t2.start();
        t3.start();
    }
}
//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url,String name)
    {
        try{
            FileUtils.copyURLToFile(new URL(url),new File(name));
        }catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

实现Runnable接口(推荐使用，可以避免Thread单继承的局限性)

执行的时候必须创建一个Thread，然后使用实现Runnable的类来构造，使用start方法来执行

public class TestThread3 implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<200;i++)
        {
            System.out.println(456);
        }
    }
    public static void main(String args[]) {
        //main 主线程
        //创建一个Runnable的实现对象
        TestThread3 t = new TestThread3();
        //创建一个Thread，把Runnable的实现类放进来,然后使用start()方法来执行线程
        new Thread(t).start();

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

实现Callable接口

用静态代理模式理解Runnable’实现原理

首先需要一个Thread对象
将实现了Runnable接口的类放入Thread中，并使用start（）方法

Thread类实现了Runnable接口，代理了Runnable，同时实现了许多Runnable无法实现的功能

以婚庆公司帮助人结婚为例：
婚庆公司就是Thread对象，实现了Runnable接口，结婚的人也实现了Runnable接口。start()方法相当于对应的动作。

线程五大状态

新生状态 Thread t = new Thread() ; 对象创建
就绪状态新生调度start()方法
运行状态 CPU开始调度，进入运行状态
阻塞状态调用sleep、wait或同步锁定的时候，线程进入阻塞状态。等待再次调用
死亡状态线程中断或结束

停止线程

stop() 不推荐使用
destroy() 不推荐使用
试用一个标志位flag ，在代码中改变标志位状态来停止线程 （让线程结束而自己停止）

sleep线程（休眠）

指定当前线程阻塞的毫秒数
sleep存在异常InterruptedException
sleep时间达到后线程进入就绪状态
sleep可以模拟网络延时，倒计时等
每个对象都有一个锁，sleep不会释放锁

线程礼让（yield）

让当前正在执行的线程暂停，但不阻塞，从运行状态转化为就绪状态，但是礼让不一定成功（看CPU心情）

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()+"线程停止执行");
    }
}

线程插队 Join

Join合并线程，此线程执行完毕之后，再执行其他线程。其他线程阻塞（插队）

public class TestJoin implements Runnable{
    public static void main(String[] args) {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();
        //插主线程main的队
        for(int i=0;i<100;i++)
        {
            if(i==40)
            {
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main"+i);
        }
    }
    @Override
    public void run() {
        for(int i=0;i<20;i++)
        {
            System.out.println("我插队了");
        }
    }
}

观测线程状态

NEW : 创建但是还未启动
RUNNABLE ：正在执行
BLOCKED ：被阻塞
WAITIN ：被阻塞等待其他线程的动作
TIMED_WATTING ：被阻塞等待其他线程的动作，并且已经到达了指定时间
TERMINATED ：线程已退出

/*
观察线程的状态
*/
public class TestState {
    public static void main(String[] args) {
        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);

        //观察线程启动之后状态
        thread.start();
        System.out.println(state);

        while(state!=Thread.State.TERMINATED)
        {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state = thread.getState();
            System.out.println(state);
        }
    }
}

线程的优先级

最小为1
默认为5

最大为10

优先级只代表了线程被调用的概率高，高优先级并不一定先调用

public class TestPriority {
    public static void main(String[] args) {
        //主线程 优先级默认
        System.out.println(Thread.currentThread().getName()+"---->"+Thread.currentThread().getPriority());
        MyPriority myPriority = new MyPriority();
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);
        //先设置优先级，再启动
        t1.start();
        t2.setPriority(1);
        t2.start();
        t3.setPriority(4);
        t3.start();
        t5.start();
        t6.start();
    }
}

class MyPriority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"---->"+Thread.currentThread().getPriority());
    }
}

守护（daemon）线程

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

例如：后台日志记录、监控内存、垃圾回收

**需要 thread.setDaemon(true); **

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); //true表示是守护线程
        thread.start(); //守护线程启动

        Thread t = new Thread(people); 
        t.start(); //用户线程启动
    }
}
//观音菩萨线程(守护)
class God implements Runnable{

    @Override
    public void run() {
        while(true)
        {
            System.out.println("观音菩萨保佑你");
        }
    }
}
//人类线程
class People implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<36500;i++)
        {
            System.out.println("你开心地活着");
        }
        System.out.println("ByeBye!World!");
    }
}

线程同步：形成 ——> 队列+锁

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

队列和锁

队列：线程同步是一种等待机制，让所有操作同一对象的线程进入同一个等待池形成队列

锁机制(synchronized) ：当一个对象获得一个排它锁，就独占资源，其他线程必须等待锁释放。

锁机制问题

降低性能
优先级与锁起冲突，会引起性能倒置

不安全案例

public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"甲").start();
        new Thread(buyTicket,"乙").start();
        new Thread(buyTicket,"丙").start();

    }
}
class BuyTicket implements Runnable{
    //票
    private int ticketNums = 10;
    boolean flag = true ;
    @Override
    public void run() {
        //买票
        while(flag){
            //noinspection BusyWait
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            buy();
        }
    }
    private void buy(){
        //判断是否有票
        if(ticketNums<=0)
        {
            flag = false;
            return;
        }
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums);
        ticketNums--;
    }
}

上述代码会出现多个消费者购买同一张票的情况，这是不安全的。

因此需要给线程上锁synchronized

同步方法

synchronized方法控制对对象的访问，每个对象对应一把锁，每个synchronized方法必须获得该锁才行，否则线程会被阻塞，方法一旦执行就独占该锁，方法结束释放锁

在这里插入图片描述

同步块 : 将一个需要增删改的对象作为同步监视器

在这里插入图片描述

synchronized(Obj){}

Obj称为 同步监视器
Obj可以使任何对象，推荐使用共享资源作为同步监视器
同步方法中无需指定同步监视器，其同步监视器默认为this

同步监视器的执行过程
1. 第一个线程访问，锁定同步监视器，执行其中代码
2. 第二个线程访问，发现同步监视器被锁定，无法执行
3. 第一个线程执行完毕，解锁同步监视器
4. 第二个线程发现同步监视器没有锁，锁定并执行

缺点是会影响效率

JUC并发包

线程安全LIst : CopyOnWriteArrayList

在这里插入图片描述

这个集合自带保证线程安全

Lock锁：显式定义的锁

ReentrantLock类（可重复锁）实现了Lock，它拥有与synchronized具有相同的并发性和内存语义。可以用于显式加锁和释放锁。
在这里插入图片描述

通过ReentrantLock类的lock方法可以通过语句的形式显式加锁

死锁

两个都在等对方释放资源的时候，就会发生死锁。当某一个同步块同时拥有两个以上对象锁时，就可能会发生死锁问题

产生死锁的四个必要条件：

互斥条件：一个资源每次只能被一个进程使用
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件：进程已获得的资源，在未使用完之前，不能够强行剥夺
循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

线程协作（生产者消费者模式？）

$## [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rhrQtJxF-1619366284872)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210425225232235.png)]$

显然如果要解决上述的问题，仅仅通过synchronized是不够的

synchronized可阻止并发更新同一个线程资源，可以实现同步
但是synchronized不能用来实现不同线程之间的消息传递

为了解决线程通信问题，提供了以下机制(下列方法直接来自Object，与Thread无关) ：

wait() : 表示线程一直等待，直到线程通知。 wait()与sleep()不同，wait（）会释放锁
wait(long timeout) : 指定等待的毫秒数
notify（）：唤醒一个处于等待状态的线程
notifyAll() : 唤醒同一个对象上所有调用wait()方法的线程，优先级高的线程优先调度

管程法（利用缓冲区解决）

public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Producer(container).start();
        new Consumer(container).start();
    }
}
//生产者
class Producer extends Thread{
    SynContainer container ;
    public Producer(SynContainer container)
    {
        this.container = container;
    }
    //生产

    @Override
    public void run() {
        for(int i=0;i<100;i++)
        {
            container.push(new Chicken(i));
            System.out.println("生产第"+i+"只鸡");
        }
    }
}
//消费者
class Consumer extends Thread{
    SynContainer container ;
    public Consumer(SynContainer container)
    {
        this.container = container;
    }

    //消费
    @Override
    public void run() {
        for(int i=0;i<100;i++)
        {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("消费了第"+container.pop().id+"只鸡");
        }
    }
}
//产品
class Chicken{
    public int id;
    public Chicken(int id)
    {this.id = id;}
}
//缓冲区
class SynContainer{
    //需要一个容器大小
    Chicken[] chickens = new Chicken[10];
    //容器计数器
    int count  = 0;
    //生产者放入产品
    public synchronized void push(Chicken chicken)
    {
        //如果容器满了，就等待消费
        if(count==chickens.length)
        {
            //生产者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满，继续放入产品
        else
        {
            chickens[count] = chicken;
            count++;
            //可以通知消费者消费了
            this.notifyAll();
        }
    }

    //消费者消费产品
    public synchronized Chicken pop(){
        //判断能否消费
        if(count==0) {
            //等待生产者生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            count--;
            Chicken chicken = chickens[count];
            //吃完了，通知生产者生产
            this.notifyAll();
            return chicken;
        }
        return null;
    }

}

在上方例子中，生产者和消费者都只在自己的线程里进行自己的生产与消费操作。通过引入同一个缓冲区 SynContainer,实现了线程之间的交互。在SynContainer中通过wait()来阻塞当前的线程，通过notifyAll()来唤醒在同一个 SynContainer上发生了wait()的线程

需要弄清楚缓冲区notify()、wait()与实际线程的作用方式

在Producer和Consumer中都调用了 SynContainer的方法，wait()和notify（）通过这层关系阻塞或唤醒了当前运行的线程

notifyAll()检测所有在 SynContainer中wait()的线程，并给予全部唤醒操作

信号灯法（标志位解决）

public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}
//生产者 演员
class Player extends  Thread{
    TV tv;
    public Player(TV tv)
    {
        this.tv = tv;
    }
    //演员表演
    @Override
    public void run() {
        for(int i=0;i<20;i++)
        {
            if(i%2==0)
            {
                this.tv.play("节目1");
            }else{
                this.tv.play("节目2");
        }
        }
    }
}
//消费者 观众
class Watcher extends  Thread{
    TV tv;
    public Watcher(TV tv)
    {
        this.tv = tv;
    }
    //观看

    @Override
    public void run() {
        for(int i=0;i<20;i++)
        {
            tv.watch();
        }
    }
}
//产品 - 节目
class TV{
    //演员表演 ， 观众等待 flag = True
    //观众观看 ， 演员等待 flag = False
    String performation ; //表演的节目
    boolean flag = true;
    //表演
    public synchronized void play(String performation)
    {
        if(!flag)
        {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了"+performation);
        //通知观众观看
        this.notifyAll();
        this.performation = performation;
        this.flag = !this.flag;
    }
    //观看
    public synchronized void watch()
    {
        if(flag)
        {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了:"+performation);
        //通知演员表演
        this.notifyAll();
        this.flag = !this.flag;
    }
}

线程池

提出原因

经常创建、销毁线程，对性能的影响较大

原理

提前创建好多个线程，放入线程池，使用的时候直接获取，使用完毕放回线程池。

这样可以避免频繁地创建、销毁线程，实现重复利用

优点

提高响应速度
降低资源消耗
便于线程管理

使用线程池

相关API ：ExceutorService 和 Executors

ExceutorService ：真正的线程池接口，常见子类 ThreadPoolExecutor
- void execute(Runnable command) : 执行任务
- Future submit(Callable task) : 执行任务，执行Callable
- void shutdown() ：关闭线程池
Executors : 工具类 ，线程池的工具类，用于创建并返回不同类型的线程池

需要通过Executors来为ExecutorService创建线程池子（控制池子大小）

public class TestThreadPool {
    public static void main(String[] args) {
        //1.创建服务，创建线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //2.执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //3.关闭线程池
        service.shutdown();


    }
}
class MyThread implements Runnable{

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

陆源东

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程

主线程与子线程进程与线程进程是执行程序的一次执行过程，是一个动态的概念，是系统分配资源的单位一个进程可以包含若干个线程，线程是CPU调度和执行的单位模拟多线程真实多线程是指多个CPU，而实际上程序中的多线程是用一个CPU模拟多线程，只不过切换的很快，模拟了同时进行的效果。线程创建1.继承Thread类Thread实现了Runnable接口1.自定义线程类继承Thread2.重写run（）方法，编写线程执行体3.创建线程对象，调用start（）方法启动线程run()方法与star
复制链接

扫一扫