JAVA进阶（线程与进程）

最新推荐文章于 2024-06-05 21:00:00 发布
最新推荐文章于 2024-06-05 21:00:00 发布
阅读量91 收藏
点赞数
分类专栏： JAVA进阶 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43563049/article/details/107897400
版权

一，进程与线程

  • 进程是资源分配的最小单位，线程是资源调度（程序执行）的最小单位
  • 进程指一次程序的完整运行，一个进程包含多个线程，线程比进程处理快，线程的存在离不开进程，一个线程终止整个进程将终止，而进程之间不会相互影响
  • 例如打开微信，就相当于启动一个进程，打开朋友圈，微信运动等相当于执行线程
  • 再例如，进程相当于火车，线程相当于车厢

二，多线程的实现方法

  • 实现多线程的两种方式：继承Thread类，继承Runnable接口
  • Thread 类start()方法用于启动多线程,自动调用run()方法（这是由jvm所决定的），run()地位相当于main()，都是程序的入口，run()是线程程序的入口，main()是主程序的入口。
  • 启动顺序并不等于执行顺序，先start()不一定先run()
  • Runnable接口 没有start()方法，但可以使用 public Thread(Runnable target){}，调用该接口的子类对象
package 进程与线程;

class MyThread extends Thread{
    private String str;

    public MyThread(String str)
    {this.str=str;}

    //覆写Run方法
    @Override
    public void run() {
        for (int i = 0; i <200 ; i++) {
            System.out.println(this.str+"--->"+i);
        }
    }
}

public class ThreadDemo  {
    public static void main(String[] args) {
        MyThread m1 = new MyThread("线程1");
        MyThread m2 = new MyThread("线程2");
        MyThread m3 = new MyThread("线程3");
        m1.start();
        m2.start();
        m3.start();

    }
}


package 进程与线程;

class MyThread  implements Runnable{
    private String str;

    public MyThread(String str)
    {this.str=str;}

    //覆写Run方法
    @Override
    public void run() {
        for (int i = 0; i <200 ; i++) {
            System.out.println(this.str+"--->"+i);
        }
    }
}

public class ThreadDemo  {
    public static void main(String[] args) {
        MyThread m1 = new MyThread("线程1");
        MyThread m2 = new MyThread("线程2");
        MyThread m3 = new MyThread("线程3");

        new Thread(m1).start();
        new Thread(m2).start();
        new Thread(m3).start();
    }
}
  • Thread类是Runnable的子类，接口实现了多继承
    在这里插入图片描述

三，进程与线程的比较

  • 多个线程对象访问同一资源用Runnable接口，实现资源共享（车厢a换到车厢b），而进程之间很难实现资源共享
package 进程与线程;

class MyThread extends Thread{
    private int ticket = 10;
    //覆写Run方法
    @Override
    public void run() {

        for (int i = 0; i <50 ; i++) {
            if(ticket>0)
            System.out.println("剩余票数："+"--->"+ticket--);
        }
    }
}

public class ThreadDemo  {
    public static void main(String[] args) {
        MyThread m1 = new MyThread();
        MyThread m2 = new MyThread();
        MyThread m3 = new MyThread();
        m1.start();
        m2.start();
        m3.start();
    }
}
  • 实例化三个不同的线程对象，每个线程对象对各自的ticket进行操作，没有实现资源共享
    在这里插入图片描述

在这里插入图片描述

package 进程与线程;

class MyThread implements Runnable{
    private int ticket = 10;
    //覆写Run方法
    @Override
    public void run() {

        for (int i = 0; i <50 ; i++) {
            if(ticket>0)
            System.out.println("剩余票数："+"--->"+ticket--);
        }
    }
}

public class ThreadDemo  {
    public static void main(String[] args) {
        MyThread m1 = new MyThread();
        new Thread(m1).start();
        new Thread(m1).start();
        new Thread(m1).start();
    }
}
  • 实例化三个Thread类进程对象，每个进程对象对应同一个MyThread子类对象，可以实现资源共享
    在这里插入图片描述
  • 关于ticket输出不是10,9,8,7,6,5,4,3,2,1,0，以为ticket不是原子操作，受到线程的影响，可能先println,再进行ticket- -，或者先进行ticket- -再进行println <可以这样理解，卖出票时要记下剩余票数并报出（println），许多票贩分布在大街小巷卖票a卖出了一张票（ticket - -），b卖出了一张票（ticket - -）,这时b先当时记下报出剩余票数，a后报出当时记下的剩余票数>
    在这里插入图片描述
    四，多线程的同步问题：
    1.问题的引出：多个线程访问同一资源，例如多个票贩卖同一张票，票数出现负数的情况。
package 进程与线程;
class MyThread implements Runnable{
    private int ticket = 10;
    //覆写Run方法
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            if(ticket>=0)
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            System.out.println(Thread.currentThread().getName()+"--->"+ticket--);
        }
    }
}
public class ThreadDemo  {
    public static void main(String[] args) {
        MyThread m1 = new MyThread();
        new Thread(m1,"票贩子a").start();
        new Thread(m1,"票贩子b").start();
        new Thread(m1,"票贩子c").start();
    }
}

在这里插入图片描述
在这里插入图片描述

  • 第一个线程执行并休眠时，没有进行ticket - - ，当前票数仍为1，所以第二个线程执行时，通过了剩余票数的判断，最后进行修改剩余票数时，会出现负数的情况。

2.解决方法：使用synchronized(){},进行上锁，以下两种方法都是为了保证同一时间只有一个线程被执行，其他线程必须等待该线程执行完成才能执行，即同一时间只有一个票贩卖票。
在这里插入图片描述

  • 同步代码块
package 进程与线程;
class MyThread implements Runnable{
    private int ticket = 10;
    //覆写Run方法
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            synchronized (this) {//当前操作只允许一个线程对象进入
                if (this.ticket >= 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "--->" + this.ticket--);
                }
            }
        }
    }
}
public class ThreadDemo  {
    public static void main(String[] args) {
        MyThread m1 = new MyThread();
        new Thread(m1,"票贩子a").start();
        new Thread(m1,"票贩子b").start();
        new Thread(m1,"票贩子c").start();
    }
}

在这里插入图片描述

  • 同步函数
package 进程与线程;
class MyThread implements Runnable{
    private int ticket = 10;
    //覆写Run方法
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
           this.sale();
        }
    }
    public synchronized void sale()
    {
            if (this.ticket >= 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "--->" + this.ticket--);
            }
    }

}
public class ThreadDemo  {
    public static void main(String[] args) {
        MyThread m1 = new MyThread();
        new Thread(m1,"票贩子a").start();
        new Thread(m1,"票贩子b").start();
        new Thread(m1,"票贩子c").start();
    }
}

在这里插入图片描述
在这里插入图片描述

  • 将判断剩余票数，休眠，修改剩余票数用synchronized进行封装上锁，使得同一时间只能有一个线程对象执行这个完整操作
  • 同步操作与异步操作相比，执行速度低于异步操作，但同步操作的安全性高。

五，多线程经典模型-----生产者与消费者：生产一个，取走一个进行输出，不存在连续重复输出同一个产品，而且产品的特点不会产生错乱的情况，实现了线程有序交替执行。
在这里插入图片描述

package 进程与线程;
class Info
{
    private String title;
    private String content;
    private boolean flag  = true;
    //flag=true,可以生产不可以取走，flag=flase 可以取走不可以生产
    public synchronized void set(String title,String content) throws InterruptedException {
        if(this.flag==false)//重复进入set()，发现不可以生产，进行等待
        {
            super.wait();
        }
        this.title=title;
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.content=content;
        this.flag=false;//生产完后进行标记修改
        super.notify();//唤醒其他等待取出数据线程
    }
    public synchronized void get() throws InterruptedException {
        if(flag==true)//重复进入get()，数据正在生产中，发现取不到数据，进行等待
        {
            super.wait();
        }
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.title+"---->"+this.content);
        this.flag=true;//取走数据，进行标记的修改
        super.notify();//唤醒其他等待生产数据线程
    }
}
class Productor implements Runnable{
    private Info info;
    public Productor(Info info)
    {this.info=info;}

    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            if(i%2==0) {
                try {
                    this.info.set("生产油桃", "饱满多汁");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        else {
                try {
                    this.info.set("生产哈密瓜","香甜可口");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
class Customer implements Runnable {
    private Info info;

    public Customer(Info info) {
        this.info = info;
    }

    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            try {
                this.info.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
    public class ThreadDemo1 {
        public static void main(String[] args) {
            Info info = new Info();
            new Thread(new Productor(info)).start();
            new Thread(new Customer(info)).start();
        }
}

在这里插入图片描述

  • sleep()与wait()区别，sleep()是Thread类定义的方法，wait()是Object类定义的方法
    sleep()可以设置休眠时间，时间一到自动唤醒，wait()休眠需要notify()进行唤醒
hellσ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程之进阶篇(一).docx
04-16
与此相反，像java所使用的这种并发系统会共享内存或I/O这样的资源，因此编程编写多线程程序最基本的困难在于，协调不同线程驱动的任务之间这些资源的使用，以便使得这些资源不会同时被多个任务访问。
Java多线程之进阶篇(二).docx
04-16
与此相反，像java所使用的这种并发系统会共享内存或I/O这样的资源，因此编程编写多线程程序最基本的困难在于，协调不同线程驱动的任务之间这些资源的使用，以便使得这些资源不会同时被多个任务访问。
初级+进阶+高级！带你搞懂Java开发线程特点知识
传智播客的专栏
05-31 152
黑马视频号今天，播妞和大家分享的是Java开发线程特点基础知识，不管是初学者还是高级用户或者是Java专家都需要了解，一起来学习吧！Java开发线程特点基础知识· 初学者阶段1、线...
Java(高阶)——线程
weixin_48377363的博客
01-07 1206
线程单进程单线程多进程单线程单进程多线程多进程多线程进程中的线程多线程的问题 单进程单线程 一个小明吃100个蛋糕肯定吃不完,效率很低.而且小明可能会被撑死 ???? 多进程单线程 为了加快吃草莓蛋糕的速度,我们采用并发编程,采用多进程单线程的方式.就是说有两个房间和桌子,然后让小明的兄弟小跳去另一件房子吃50个草莓蛋糕,帮小明分担了50个草莓蛋糕.这时这俩兄弟互相互相不知道对方吃的多快,这就叫进程之间的数据是不共享的(进程的隔离性). 单进程多线程 和上一个版本相比,吃的效率高了很多,而且资源也没有额
Java高级特性--进程与线程
weixin_46511924的博客
05-29 151
Java高级特性–进程与线程 1、多线程 ​ 如果在一个进程中同时运行了多个线程,用来完成不同的工作,则称之为"多线程" ​ 多个线程交替占用CPU资源,而非真正的并行执行 多线程的好处 ​ ①充分利用CPU的资源 ​ ②简化编程模型 ​ ③带来良好的用户体验 主线程 ​ Thread类 ​ java提供了java.lang.Thread类支持多线程的编程 ​ 主线程 ​ main( )方法即为主线程入口 ​ 产生其他子线程的线程 ​ 必须最后完成执行,因为它
【高级开发进阶】6.2 什么是线程 深入理解Java线程
Java程序员廖志伟
01-25 1477
学完本章中，读者需要回答： 1．什么是线程？什么是进程？ 2. 线程有哪些状态？ 3. 什么是线程安全？ 什么是线程？什么是进程？ 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。如图6.2所示。比如我们常用的QQ、电脑管家等等都是独立的进程。 图6.2 进程 看到的这些单独运行的程序就是一个独立的进程，进程之间是相互独立存在的。 线程有哪些状态？ 在Java当中，线程通常都有五种状态，创建、就绪、运行、阻塞和死亡。 第一是创建状态。在生成...
Java 第23天 高级进阶篇 线程安全 (三.)
禧年
07-25 137
一、 线程的生命周期： 二、 线程的安全： package Com.Work_ZQ; /** 1、Runnable 接口的方式实现卖票信息 2、解决线程安全问题。 */ class window implements Runnable{ private int ticket=100; Object obj =new Object(); @Override public void run() { while (true){ // obj为同步监视器。 synchronized (obj){ if(ti
Java进阶 —— 多线程并发
荔枝当大佬的博客
07-25 824
在系统学完Java的面向对象编程之后，我们需要认真地来学习Java并发编程，我们在学习计算机操作系统的时候也都了解过进程、线程和协程的概念。在这篇文章中荔枝主要会梳理有关线程创建、线程生命周期、同步锁和死锁、线程通信和线程池的知识，并给出相应的精简示例，希望能帮助有需要的小伙伴们哈哈哈~~~
JAVA进阶 —— 多线程
hdakj22的博客
03-17 1200
多线程（线程与进程的区别以及并发与并行）、多线程三种实现方式和成员方法、线程的生命周期、线程安全的三种解决解决方式、死锁问题、等待唤醒机制以及线程池
Java多线程进阶(JUC)
black_pp的博客
09-27 657
Java多线程进阶，锁，JUC，并发安全问题
FridaHookAndroid:Frida-Android 进阶
05-26
FridaHookAndroidFrida-Android 进阶frida 版本：12.11.18系统：Ubuntu 20.04 LTS博客地址：官方 APIJava 运行时官方API地址： ，这里给出几个常用的 APIJava.perform(fn)确保当前线程被附加到 VM 上，并且调用fn...
java面试题库2021.pdf
05-22
2、 进程的描述与控制 3、 输入输出系统 4、 存储器管理 5、 处理机调度与死锁 八、 算法与数据结构 1、 哈希 2、 树 3、 遍历 4、 链表 5、 数组 6、 排序 7、 堆与栈 8、 队列 9、 高级算法 九、 设计模式 1、 ...
java基础案例与开发详解案例源码全
04-04
12.1.2 进程和线程的区别304 12.1.3 线程的创建和启动305 12.1.4 Thread类介绍308 12.1.5 为什么需要多线程309 12.1.6 线程分类309 12.2 线程的生命周期309 12.2.1 线程的状态及转换310 12.2.2 线程睡眠311 12.2.3 ...
进阶2 探索图形化编程：扩展图形组件与切片开发的魅力
优树搭的博客
05-30 1587
当这些切片成功地通过图形程序串联起来后，在后续进行程序升级或维护时，大家会惊喜地发现，图形程序就如同清晰的路标一般，可以非常便捷地通过图形程序准确地定位到相关切片，并对这些切片进行在线查看、编辑和执行等操作。而且，这些切片的代码长度通常不会太长，相比传统开发的代码，阅读起来要容易得多，这无疑会给系统后续的工作带来极大的便利。
JavaScript第九讲：BOM编程
星途码客的博客
06-04 1066
今天星途给大家带来JavaScript倒数第二部分知识：BOM编程，希望对码客们有帮助。
设计模式之装饰器模式
最新发布
丿微风乍起的博客
06-05 648
装饰器模式是一种结构型设计模式，它允许我们在不改变原有对象结构的情况下，动态地给对象增加一些职责（即增加其额外功能）。其核心在于通过组合而非继承的方式来扩展对象的功能。Component: 这是抽象组件接口，所有的具体组件和装饰器都必须实现这个接口。Concrete Component: 具体组件，这是我们要装饰的基本对象，它实现了Component接口。Decorator: 抽象装饰器，也是实现Component接口的，它包含一个对Component类型的引用，通常在构造函数中初始化。
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
Itmastergo的博客
05-31 1046
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Spring异步任务@Async的默认线程池执行器是如何初始化的
简放视野的专栏
06-03 573
Spring异步任务@Async的默认线程池执行器，是从哪里来？是如何初始化的？ 【结论】异步任务@Async的默认线程池执行器是通过TaskExecutionAutoConfiguration#applicationTaskExecutor自动注入的。
拼图小游戏
lazy_girl_666的博客
06-03 657
把A对象的属性值完全拷贝给B对象，也叫对象拷贝，对象复制。
java 线程与进程的区别
03-25
Java中的线程和进程都是并发编程中的重要概念，它们之间的区别如下： 1. 进程是操作系统中正在执行的程序，它拥有独立的内存空间和系统资源，而线程是进程的一个执行单元，它与同一进程中的其他线程共享内存空间和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值