小白猿笔记Day16

于 2021-10-26 18:11:10 发布
阅读量185 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 小白笔记 文章标签： intellij-idea java intellij idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61729112/article/details/120967636

进程与线程

进程:

进程就是正在运行的程序,它会占用对应的内存区域，由CPU进行执行与计算。

特点:

独立性:
进程是系统中独立存在的实体,它可以拥有自己独立的资源,每个进程都拥有自己私有的地址空间,在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间
动态性:
进程与程序的区别在于,程序只是一个静态的指令集合,而进程是一个正在系统中活动的指令集合,程序加入了时间的概念以后,称为进程,具有自己的生命周期和各种不同的状态,这些概念都是程序所不具备的.
并发性:
多个进程可以在单个处理器CPU上并发执行,多个进程之间不会互相影响.

eg:

电脑的操作系统OS

进程:谷歌IDEA

线程:如果有一个线程:单线程程序

        如果有多个线程:多线程程序

进程与线程的关系:

一个操作系统中可以有多个进程,一个进程中可以包含一个线程(单线程程序),也可以包含多个线程(多线程程序)

每个线程在共享同一个进程中的内存的同时,又有自己独立的内存空间.
所以想使用线程技术,得先有进程,进程的创建是OS操作系统来创建的,一般都是C或者C++完成 

进程与线程的关系 

 多线程的特性

  随机性

宏观上觉得多个进程是同时运行的,但实际的微观层面上，一个CPU【单核】只能执行一个进程中的一个线程。

是因为CPU以纳秒级别甚至是更快的速度高效切换着，超过了人的反应速度，这使得各个进程从看起来是同时进行的,也就是说,宏观层面上,所有的进程看似并行【同时运行】,但是微观层面上是串行的【同一时刻,一个CPU只能处理一件事】。

 

 

 串行与并行

串行是指同一时刻一个CPU只能处理一件事，类似于单车道
并行是指同一时刻多个CPU可以处理多件事，类似于多车道

 

串行:同一时刻一个cpu只能处理一个是事件

 

 

并行:同一时刻多个CPU处理多个事件

 总结:

我们控制不了OS的时间片分配,OS有自己的算法,比如FCFS,SJS

  1. FCFS(First Come First Service 先来先服务算法)

  2. SJS(Short Job Service短服务算法)

 线程的状态:

三态模型:由于线程状态比较复杂,我们由易到难,先学习线程的三种基础状态及其转换,简称”三态模型”----是基础

就绪(可运行)状态：线程已经准备好运行，只要获得CPU，就可立即执行

执行(运行)状态：线程已经获得CPU，其程序正在运行的状态

阻塞状态：正在运行的线程由于某些事件（I/O请求等）暂时无法执行的状态，即线程执行阻塞

 

就绪 → 执行:为就绪线程分配CPU即可变为执行状态"
执行 → 就绪:正在执行的线程由于时间片用完被剥夺CPU暂停执行,就变为就绪状态
执行 → 阻塞:由于发生某事件,使正在执行的线程受阻,无法执行,则由执行变为阻塞
(例如线程正在访问临界资源,而资源正在被其他线程访问)
反之,如果获得了之前需要的资源,则由阻塞变为就绪状态,等待分配CPU再次执行

创建状态:线程的创建比较复杂,需要先申请PCB,然后为该线程运行分配必须的资源,并将该线程转为就绪状态插入到就绪队列中

终止状态:等待OS进行善后处理,最后将PCB清零,并将PCB返回给系统

 PCB(Process Control Block)

为了保证参与并发执行的每个线程都能独立运行,OS配置了特有的数据结构PCB来描述线程的基本情况和活动过程,进而控制和管理线程------大白话经营许可证

 线程状态与代码对照

注释:

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

新建状态(New) : 当线程对象创建后就进入了新建状态.如:Thread t = new MyThread();
就绪状态(Runnable):当调用线程对象的start()方法,线程即为进入就绪状态.
处于就绪(可运行)状态的线程,只是说明线程已经做好准备,随时等待CPU调度执行,并不是执行了t.start()此线程立即就会执行
运行状态(Running):当CPU调度了处于就绪状态的线程时,此线程才是真正的执行,即进入到运行状态
就绪状态是进入运行状态的唯一入口,也就是线程想要进入运行状态状态执行,先得处于就绪状态
阻塞状态(Blocked):处于运状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入就绪状态才有机会被CPU选中再次执行.
根据阻塞状态产生的原因不同,阻塞状态又可以细分成三种:
等待阻塞:运行状态中的线程执行wait()方法,本线程进入到等待阻塞状态
同步阻塞:线程在获取synchronized同步锁失败(因为锁被其他线程占用),它会进入同步阻塞状态
其他阻塞:调用线程的sleep()或者join()或发出了I/O请求时,线程会进入到阻塞状态.当sleep()状态超时.join()等待线程终止或者超时或者I/O处理完毕时线程重新转入就绪状态
死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期

 

 多线程实现方案一:继承Thread类

1.自定义一个类,继承Thread类

2.在自定义中重写父类Thread中的run(),这个run()里放着的使我们自己  的业务

3.创建自定义线程类对象--对应的是线程的新建状态

4.调用start()以多线程的方式将多个线程对象加入到就绪队列中,等待OS选中

run()与start()的区别

run():主要用来封装我们自定义的业务代码,直接调用本方法,相当于普通方法的调用

start():主要是用来多线程的方式启动线程,然后有JVM(虚拟机)调用本线程的run()执行业务

注意:这里的启动指的是将线程对象加入到(就绪)队列中,具体什么时候执行还的看OS

测试:Thread

多线程实现方案2:实现Runnable接口

1.自定义多线程类,并实现Runnable接口

2.添加父接口中未实现的run(),run()里放着的是我们的业务 

3.创建自定义类的对象,只创建一次,作为业务对象存在

4.创建多个Thread线程类的对象,并将业务对象交给线程对象完成

5.以多线程的方式启动多个线程对象

测试:Runnable

 案例一：售票篇

需求:设计多线程编程模型,4个窗口共计售票100张

本方法使用多线程的实现方案1:extends Thread

package cn.tedu.tickets;
/*需求:设计多线程编程模型,4个窗口共计售票100张
 * 本方法使用多线程的实现方案1:extends Thread*/
public class TestThread {
    public static void main(String[] args) {
        //5.创建多个线程对象
        TicketsThread t1 = new TicketsThread();
        TicketsThread t2 = new TicketsThread();
        TicketsThread t3 = new TicketsThread();
        TicketsThread t4 = new TicketsThread();
        //6.以多线程的方式启动
            t1.start();
            t2.start();
            t3.start();
            t4.start();
    }
}
//1.自定义线程售票类,继承Thread
class TicketsThread extends Thread {
    //3.定义变量,用来保存要卖的票
    /*问题:4个线程对象共计售票400张,原因时创建了4个不同的线程对象
    * 每个对象都把票数tickets看作字节独有的成员变量,互不影响
    * 解决:将票数的设为静态,让全局所有对象共享*/
    static int tickets = 100;
    //重写父类中的run(),里面是我们的业务
    @Override
    public void run() {
        //3.1循环一直卖票
        while (true) {
            //3.2打印当前正在售票的线程,并且买次买票 票数-1
            System.out.println(getName() + "=" + tickets--);
            //3.3如果没有票了,结束循环 如果if后大括号里只有一句好,大括号可以省略
            if (tickets <= 0) break;//注意,死循环一定要有接口
        }
    }
}

 利用接口方案二:

本方法使用多线程的实现方案2:implements Runnable

public class TestThread {
    public static void main(String[] args) {
        //5.创建多个线程对象
        TicketsThread t1 = new TicketsThread();
        TicketsThread t2 = new TicketsThread();
        TicketsThread t3 = new TicketsThread();
        TicketsThread t4 = new TicketsThread();
        //6.以多线程的方式启动
            t1.start();
            t2.start();
            t3.start();
            t4.start();
    }
}
//1.自定义线程售票类,继承Thread
class TicketsThread extends Thread {
    //3.定义变量,用来保存要卖的票
    /*问题:4个线程对象共计售票400张,原因时创建了4个不同的线程对象
    * 每个对象都把票数tickets看作字节独有的成员变量,互不影响
    * 解决:将票数的设为静态,让全局所有对象共享*/
    static int tickets = 100;
    //重写父类中的run(),里面是我们的业务
    @Override
    public void run() {
        //3.1循环一直卖票
        while (true) {
            //3.2打印当前正在售票的线程,并且买次买票 票数-1
            System.out.println(getName() + "=" + tickets--);
            //3.3如果没有票了,结束循环 如果if后大括号里只有一句好,大括号可以省略
            if (tickets <= 0) break;//注意,死循环一定要有接口
        }
    }
}

 同步与异步

同步与异步的概念:
同步：

体现了排队的效果，同一时刻只能有一个线程独占资源，其他没有权利的线程排队。
缺点:坏处就是效率会降低，不过保证了安全。
异步：

体现了多线程抢占资源的效果，线程间互相不等待，互相抢占资源。
缺点:坏处就是有安全隐患,效率要高一些。

同步synchronized关键字

写法

synchronized (锁对象){
需要同步的代码(也就是可能出现问题的操作共享数据的多条语句);
}

同步效果的使用有两个前提:

  • 前提1：同步需要两个或者两个以上的线程(单线程无需考虑多线程安全问题)

  • 前提2：多个线程间必须使用同一个锁(我上锁后其他人也能看到这个锁,不然我的锁锁不住其他人,就没有了上锁的效果)

 特点
* 在同步代码块中的代码,同一时刻只会被一个线程执行
* 注意：同步代码块必须保证所有线程对象使用同一把唯一的锁
* 锁对象必须唯一！！！锁对象的类型不做限制，唯一就行*/

 

改造买票架构,解决重复与过售
设计多线程编程模型

public class TestThreadV2 {
    public static void main(String[] args) {
        //5.创建多个线程对象
        TicketsThreadV2 t1 = new TicketsThreadV2();
        TicketsThreadV2 t2 = new TicketsThreadV2();
        TicketsThreadV2 t3 = new TicketsThreadV2();
        TicketsThreadV2 t4 = new TicketsThreadV2();
        //6.以多线程的方式启动
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

//1.自定义线程售票类,继承Thread
class TicketsThreadV2 extends Thread {
    //3.定义变量,用来保存要卖的票
    /*问题:4个线程对象共计售票400张,原因时创建了4个不同的线程对象
     * 每个对象都把票数tickets看作字节独有的成员变量,互不影响
     * 解决:将票数的设为静态,让全局所有对象共享*/
    static int tickets = 100;
    static Object o = new Object();

    //重写父类中的run(),里面是我们的业务
    @Override
    public void run() {
        //3.1循环一直卖票
        while (true) {
            //synchronized (o) {//可以
            /*我们每通过class关键字创建一个类,就会在工作空间中生成唯一对应的类名,class字节码文件
            * 这个类名,class对应的对象,我们称之为这个类的字节码对象
            * 字节码对象及其重要,是反射技术的基石,字节码对象中包灰暗了当前类所有的关键信息
            * 所有,用这样一个唯一且明确的对象作为同步代码块的锁对象,再合适不过了*/
            synchronized (o) {
                if (tickets > 0) {
                    try {
                        Thread.sleep(10);//让当前休眠10ms
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    //3.2打印当前正在售票的线程,并且买次买票 票数-1
                    System.out.println(getName() + "=" + tickets--);
                }
                //3.3如果没有票了,结束循环 如果if后大括号里只有一句好,大括号可以省略
                if (tickets <= 0) break;//注意,死循环一定要有接口
            }
        }
    }
}

本方法使用多线程的实现方案:implements Runnable

public class TestRunnableV2 {
    public static void main(String[] args) {
        //5.创建自定义类对象,作为要完成的目标业务对象
        TicketsRunnableV2 target = new TicketsRunnableV2();
        //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();
        t2.start();
        t3.start();
        t4.start();
    }
}
/*同步锁:相当于给容易出现问题的加了一把锁,包裹了所有可能会出现数据安全的代码
* 加锁之后,就有了同步(排队)的效果,但是,加锁的范围需要考虑:
* 不能太大,太大,干啥都要排队,.效率低,也不能太小,太小,锁不住,还是会有安全隐患
* */
//1.自定义业务类
class TicketsRunnableV2 implements Runnable {
    //3.定义成员遍历用来保存票数
     int tickets = 100;
     Object o=new Object();

    //2.添加接口中为实现的run（），里面时我们的业务
    @Override
    public void run() {
        //4.实现售票的业务
        while (true) {
            /*同步代码块:synchronized(锁对象){会出现安全隐患的所有代码}
            * 在同步代码块中的代码,同一时刻只会被一个线程执行
            * 注意：同步代码块必须保证所有线程对象使用同一把唯一的锁*/
           // synchronized (new Object) { //不对！！这样的锁对象不唯一
            synchronized (o) {
                if (tickets>0) {
                    try {
                        Thread.sleep(10);//让当前休眠10ms
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    //4.1打印当前正在售票的线程名& 票数-1
                    System.out.println(Thread.currentThread().getName() + "=" + tickets--);
                }
                if (tickets <= 0) break;
            }
        }
    }
}

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值