Java多线程理解练习，从小白到熟练掌握理解多线程

最新推荐文章于 2024-07-22 23:02:05 发布

小时候的梨甜

最新推荐文章于 2024-07-22 23:02:05 发布

阅读量169

点赞数 2

文章标签： java 多线程同步锁后端

本文链接：https://blog.csdn.net/weixin_56309075/article/details/118895883

版权

多线程

1 进程

1.1 概念

 进程就是正在运行的程序,它代表了程序所占用的内存区域

2 线程

2.1 概念

线程是操作系统OS能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位.

一个进程可以开启多个线程,其中有一个主线程来调用本进程中的其他线程

我们看到的进程的切换，切换的也是不同进程的主线程

多线程扩展了多进程的概念,使的同一个进程可以同时并发处理多个任务

简而言之,一个程序运行后至少一个进程,一个进程里包含一个线程(单线程)或者多个线程(多线程)
在这里插入图片描述

2.2 进程与线程的关系

一个操作系统中可以有多个进程,一个进程中可以有多个线程

每个线程有自己独立的内存,每个线程共享一个进程中的内存,每个线程又有自己独立的内存(这个非常重要!!!)

所以想使用线程技术,得先有进程,进程的创建是OS操作系统创建的.我们不能实现,一般都是C或者C++完成

在这里插入图片描述

3 多线程的特性

3.1 随机性

线程的随机性指的是同一时刻,只有一个程序在执行

我们宏观上觉得这些程序像是同时运行,但是实际上微观时间是因为CPU在高效的切换着，这使得各个程序从表面上看是同时进行的,也就是说,宏观层面上,所有的进程/线程看似同时运行,但是微观层面上,同一时刻,一个CPU只能处理一件事.

时间单位:1/ms甚至更快,切换的速度是纳秒级别的,非常快

在这里插入图片描述

3.2 CPU分时调度

时间片,即CPU分配给各个线程的一个时间段,称作它的时间片,即该线程被允许运行的时间，
如果在时间片用完时线程还在执行,那CPU将被剥夺并分配给另一个线程,将当前线程挂起,
如果线程在时间片用完之前阻塞或结束,则CPU当即进行切换,从而避免CPU资源浪费,
当再次切换到之前挂起的线程,恢复现场,继续执行。

注意:我们无法控制OS如何选择以及选择哪些线程来执行,OS底层有自己规则:

FCFS(First Come First Service 先来先服务算法) SJS(Short Job Service短服务算法)

在这里插入图片描述

3.3 线程五种状态

线程生命周期,主要有五种状态:

新建状态(New) : 当线程对象创建后就进入了新建状态.如:Thread t = new MyThread();
就绪状态(Runnable):当调用线程对象的start()方法(t.start()😉,线程即为进入就绪状态.

处于就绪(可运行)状态的线程,只是说明线程已经做好准备,随时等待CPU调度执行,并不是执行了t.start()此线程立即就会执行

运行状态(Running):当CPU开始调度处于就绪状态的线程时,此线程才是真正的执行,即进入到运行状态

注意:就绪状态是进入运行状态的唯一入口,也就是线程想要进入运行状态状态执行,先得处于就绪状态

阻塞状态(Blocked):处于运状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入就绪状态才有机会被CPU选中再次执行.

根据阻塞状态产生的原因不同,阻塞状态又可以细分成三种:

a) 等待阻塞:运行状态中的线程执行wait()方法,本线程进入到等待阻塞状态

b) 同步阻塞:线程在获取synchronized同步锁失败(因为锁被其他线程占用),它会进入同步阻塞状态

c) 其他阻塞:调用线程的sleep()或者join()或发出了I/O请求时,线程会进入到阻塞状态.当sleep()状态超时.join()等待线程终止或者超时或者I/O处理完毕时线程重新转入就绪状态
死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期

在这里插入图片描述

4 多线程创建1:继承Thread

4.1 概述

Thread类本质上是实现了Runnable接口的一个实例,代表一个线程的实例

启动线程的唯一方法就是通过Thread类的start()实例方法

start()方法是一native方法,它将通知底层操作系统,.最终由操作系统启动一个新线程,操作系统将执行run()

这种方式实现的多线程很简单,通过自己的类直接extends Thread,并重写run()方法,就可以自动启动新线程并执行自己定义的run()方法

模拟开启多个线程,每个线程调用run()方法.

4.2 常用方法

构造方法

Thread() 分配新的Thread对象

**Thread(String name)**分配新的Thread对象

**Thread(Runnable target)****分配新的Thread对象

Thread(Runnable target,String name) 分配新的Thread对象

**Static Thread currentThread( )**返回对当前正在执行的线程对象的引用

Long getId() 返回该线程的标识

String getName() 返回该线程的名称

**Void run()**如果该线程使用独立的Runnable运行对象构造的,则调用该Runnable*对象的run方法

Static void sleep(long millions) 在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)

Void start() 使该线程开始执行:Java虚拟机调用该线程的run()

4.3 练习1：测试多线程的创建方式1：实现Runnable接口

package thead;

public class Test1_Thread {
    public static void main(String[] args) {
        //4.创建线程对象
        MyRunnable target = new MyRunnable();

        //5.2 问题:怎么把接口的实现类和Thread类绑定
        Thread thread1 = new Thread(target);

        //5.1如何启动线程?
        thread1.start();

        //6.--以多线程编程的方式启动,需要创建多个线程对象并启动
        //8.修改线程的名称--使用Thread类的含参构造
        Thread thread2 = new Thread(target, "杰克");
        Thread thread3 = new Thread(target, "露丝");

        thread2.start();
        thread3.start();

        //7.自己测试start()和run()的区别
        //run()只是一个普通方法执行的效果,也就是单线程顺序执行的效果,没有多线程的线现象
    }

}
//1.自定义多线程类

/**
 * 1.方式:implements Thread
 */
class MyRunnable implements Runnable {

    //2.把业务放入run(),重写了Runnable接口里的
    @Override
    public void run() {
        //3.写业务,打印10次线程名称
        for (int i = 0; i < 10; i++) {

            //问题:Runnable接口中,没有提供多余的方法维度只有一个run()

            //Thread.currentThread()获取当前正在执行业务的线程对象 getName()获取此线程对象的名称

            System.out.println(i + "=" + Thread.currentThread().getName());

        }
    }
}

4.3 练习2：测试多线程的创建方式2：继承Thread类

package thead;

public class Test02_Thread {

    public static void main(String[] args) {

        //4.创建线程对象
        MyThread t = new MyThread();/**对应的状态就是新建状态*/
        /**如果只是调用两个线程的run(),那么会先执行完一个线程,再执行另一个线程,不会有多线程的效果*/
        //t.run();//怎么去执行run()的业务?--真的可以用run()来执行我们的多线程任务吗?
        /**run()与start()本质上的区别,run()在执行时只能是当做一个顺序执行的单线程普通方法执行,并没有多线程编程的效果*/
        t.start();/**对应的状态就是就绪状态,想要使用多线程启动干活,必须调用start()才是真正的启动线程*/

        /**6.只有调用satrt()才会使线程从新建状态变成可运行状态
         * 当我们调用start()启动线程时,底层虚拟机会自动调用run()的业务
         * */

        //5.模拟多线程,需要至少启动2个线程,如果只是启动一个线程,是单线程程序
        MyThread t2 = new MyThread();

        //t2.run();
        t2.start();

        /**线程的随机性,t0 t1 t2的执行结果不可控,因为会由CPU在调度,结果有随机性*/
        /**线程的随机性:CPU会自动调度可运行状态的线程们,但是哪个时间片执行哪个线程我们无法控制*/

//      2=Thread-0
//      3=Thread-0
//      2=Thread-1
//      1=Thread-2
//      3=Thread-1

        MyThread t3 = new MyThread("小灰灰");
        t3.start();
    }
}
//1.自定义多线程类

/**
 * 1.方式1:extends Thread
 */
class MyThread extends Thread {
    /**
     * 最后:为了修改线程名称,不再使用系统分配的默认名称,需要提供含参构造
     */

    //右键-->Source-->倒数第二个-->DisSelect All-->选择无参构造或者传名字的构造
    public MyThread() {
        super();
    }

    public MyThread(String name) {
        super(name);
    }

    /**
     * 3.如果不满意run()的内容,可以重写alt+/
     */
    //2.2 重写Thread父类中的run()
    @Override
    public void run() {

        /**4.super表示父类对象的引用,也就是默认使用Thread类里的业务,不用*/
        //super.run();
        //3.写业务:输出10次当前正在执行的线程名称
        for (int i = 0; i < 10; i++) {

            /**5.getName()可以获取正在执行任务的线程名称,是从父类中继承的方法,可以直接使用*/
            System.out.println(i + "=" + getName());
        }
    }
}

5.4 两种实现方式的比较

Thread

优点: 编写简单,如果需要访问当前线程,无需使用Thread.currentThread()方法,直接使用this即可获得当前线程

缺点: 自定义的线程类已经继承了Thread类,所以后续无法再继承其他的类

Runnable

优点: 自定义的线程类只是实现了Runnable接口或Callable接口,后续还可以继承其他类

在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码、还有数据分开(解耦),形成清晰的模型,较好地体现了面向对象的思想

缺点: 编程稍微复杂,如果想要访问当前线程,则必须使用Thread.currentThread()方法

6 售票案例

设计4个售票窗口，总计售票100张。用多线程的程序设计并写出代码。

6.1方案1：实现Runnable

package thead;

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

        //3.创建对象
        TicketRunnable target = new TicketRunnable();
        Thread thread = new Thread(target);
        Thread thread2 = new Thread(target);
        Thread thread3 = new Thread(target);
        Thread thread4 = new Thread(target);

        //4.启动线程
        thread.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

//1.创建多线程类
class TicketRunnable implements Runnable {
    static int tickets = 100;

    @Override
    public void run() {
        while (true) {
            if (tickets > 0) {
                try {
                    //先让程序休眠10ms
                    //问题1：超卖，0  -1
                    //问题2：重卖，70号票卖给了两个人
                    Thread.sleep(10);//线程访问的延迟性
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //Thread.currentThread().getName()获取当前正在执行任务的线程名
                System.out.println(Thread.currentThread().getName() + "=" + tickets--);
            }
            if (tickets <= 0) break;//死循环的出口！！
        }
    }
}

在这里插入图片描述

6.2 问题

每次创建线程对象，都会生成一个tickets变量值是100，创建4次对象就生成了400张票了。不符合需求，怎么解决呢？能不能把tickets变量在每个对象间共享，就保证多少个对象都是卖这100张票。

解决方案: 用静态修饰

产生超卖，0 张、-1张、-2张。
产生重卖，同一张票卖给多人。
多线程安全问题是如何出现的？常见情况是由于线程的随机性+访问延迟。
以后如何判断程序有没有线程安全问题？

在多线程程序中 + 有共享数据 + 多条语句操作共享数据

7. 同步锁

把有可能出现问题的代码包起来，一次只让一个线程执行。

通过sychronized关键字实现同步。

当多个对象操作共享数据时，可以使用同步锁解决线程安全问题。

同步：就是体现了排队的效果，就是同一时刻只能有一个线程独占资源，没有权利的排队。坏处就是效率低，但是安全。

异步：就是体现了多线程的效果，就是互相不等待，互相抢占资源。

好处是效率高，但是不安全。

1. 特点

1．前提1：同步需要两个或者两个以上的线程

2．前提2：多个线程间必须使用同一个锁

3．同步的缺点是会降低程序的执行效率，为了保证线程安全,必须牺牲性能

4．可以修饰方法称为同步方法，使用的锁对象是this

5．可以修饰代码块称为同步代码块，锁对象可以任意

TIPS:既然是加锁,那么就需要有锁住的对象,一般锁的是当前对象this

  那为什么同步代码块的锁对象可以是o,但是同步方法必须是this呢?

   因为同步代码块同一个时刻只有一个线程进入,而同步方法可以让多个线程进入

1.2 练习:改造售票案例

package thead;

public class Test05_Thread {
    public static void main(String[] args) {
        //5.创建接口实现类对象作为业务目标对象
        TicketSync target = new TicketSync();

        //6.将目标对象交由Thread线程对象
        Thread t1 = new Thread(target);
        Thread t2 = new Thread(target);
        Thread t3 = new Thread(target);
        Thread t4 = new Thread(target);

        //7.以多线程的方式启动线程--会将线程由新建状态变为就绪状态
        t1.start();/**1.如果只创建了一个线程对象,是单线程场景,不会出现数据问题*/
        t2.start();
        t3.start();
        t4.start();
    }
}

/**
 * 2.多线程中出现数据不安全问题的前提:多线程程序 + 有共享数据(成员变量) +多条语句操作共享数据
 */

/**3.同步锁:相当于给容易出现问题的代码加了一把锁,从可能出现问题的代码开始,到问题代码结束
 * 位置:不能太大,也不能太小,太大,干啥都得排队,导致程序的效率太低,太小,没锁住
 * */

//1.通过实现Runnable接口的方式完成多线程售票案例

class TicketSync implements Runnable {

    //3.定义变量用来保存票数
    static int tickets = 100;

    Object o = new Object();//创建了一个唯一的"锁"对象,不论之后那个线程进同步代码块,使用的都是o对象,"唯一"很重要
    //2.添加未实现方法run()--写业务
    /**6.如果一个方法里的代码都被同步了,可以直接把方法修饰成同步方法,同步方法的锁对象得用this*/
    @Override
    //synchronized public void run() {//被synchronized修饰的方法是同步方法
    public void run() {//被synchronized修饰的方法是同步方法
        //4.1通过while(true)死循环的方式卖票,注意添加出口!!!
        while (true) {
            /**4.synchronized(锁对象){}--同步代码块:是指同一时间这一资源会被一个线程独享,大家使用的时候,都得排队,同步效果*/
            synchronized (o) {/**5.锁对象的要求:多线程之间必须使用同一把锁,同步代码块的方式,关于锁对象可以任意定义*/
                //synchronized (new Object()) {//不对,相当于每个线程都用了自己的锁,多个线程进来一次new一次,并不是使用的同一把锁
                //4.2通过if结构判断买票的情况
                if (tickets > 0) {//还有票
                    //8.手动添加休眠方法,创造延迟效果,注意可能会发生问题,需要由try-catch包裹
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }//10ms

                    //4.3打印的是当前卖票的线程以及票数
                    System.out.println(Thread.currentThread().getName() + "=" + tickets--);
                }
                if (tickets <= 0) break; //没有票了,退出循环,没得卖了
            }
        }
    }
}

在这里插入图片描述

小时候的梨甜

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java多线程理解练习，从小白到熟练掌握理解多线程

多线程1 进程1.1 概念进程就是正在运行的程序,它代表了程序所占用的内存区域2 线程2.1 概念线程是操作系统OS能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位.一个进程可以开启多个线程,其中有一个主线程来调用本进程中的其他线程我们看到的进程的切换，切换的也是不同进程的主线程多线程扩展了多进程的概念,使的同一个进程可以同时并发处理多个任务简而言之,一个程序运行后至少一个进程,一个进程里包含一个线程(单线程)或者多个线程(多线程)2.2 进程与线程的关系
复制链接

扫一扫