java基础学习之进程与线程（七）

最新推荐文章于 2023-11-06 17:12:32 发布
最新推荐文章于 2023-11-06 17:12:32 发布
阅读量116 收藏
点赞数
分类专栏： JavaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41283310/article/details/108579041
版权

基本概念

进程

➢进程是程序的一次动态执行过程,它经历了从代码加载、执行到执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到最终消亡的过程。多进程操作系统能同时运行多个进程(程序)，由于CPU具备分时机制，所以每个进程都能循环获得自己的CPU时间片。由于CPU执行速度非常快，使得所有程序好象是在“同时”运行一样。

线程

➢多线程是实现并发机制的一种有效手段。进程和线程一样，都是实现并发的一个基本单位。线程是比进程更小的执行单位,线程是在进程的基础之上进行的进一步划分。 所谓多线程是指一个进程在执行过程中可以产生多个线程, 这些线程可以同时存在、同时运行, 一个进程可能包含了多个同时执行的线程。

多线程的实现

➢在Java之中，如果要想实现多线程的程序，那么就必须依靠一个线程的主体类(就好比主类的概念一样，表示的是一个线程的主类) ， 但是这个线程的主体类在定义的时候也需要有一些特殊的要求， 此类需要继承Thread类或实现Runnable (Callable) 接口来完成定义。

多线程原理

多线程原理：相当于玩游戏机，只有一个游戏机（cpu），可是有很多人要玩，于是，start 是排队！等 CPU 选中你就是轮到你，你就 run()，当 CPU 的运行的时间片执行完，这个线程就继续排队，等待下一次的run()。

调用 start() 后，线程会被放到等待队列，等待 CPU 调度，并不一定要马上开始执行，只是将这个线程置于可动行状态。然后通过 JVM，线程 Thread 会调用 run() 方法，执行本线程的线程体。先调用 start 后调用 run，这么麻烦，为了不直接调用 run？就是为了实现多线程的优点，没这个 start 不行。

1.start() 方法来启动线程，真正实现了多线程运行。这时无需等待 run 方法体代码执行完毕，可以直接继续执行下面的代码；通过调用 Thread 类的 start() 方法来启动一个线程， 这时此线程是处于就绪状态， 并没有运行。 然后通过此 Thread 类调用方法 run() 来完成其运行操作的， 这里方法 run() 称为线程体，它包含了要执行的这个线程的内容， run 方法运行结束， 此线程终止。然后 CPU 再调度其它线程。
2.run() 方法当作普通方法的方式调用。程序还是要顺序执行，要等待 run 方法体执行完毕后，才可继续执行下面的代码； 程序中只有主线程——这一个线程， 其程序执行路径还是只有一条， 这样就没有达到写线程的目的。
记住：多线程就是分时利用 CPU，宏观上让所有线程一起执行 ，也叫并发。

继承Thread类来创建线程

➢Java 的线程是通过 java.lang.Thread 类来实现的。VM 启动时会有一个由主方法所定义的线程。可以通过创建 Thread 的实例来创建新的线程。每个线程都是通过某个特定 Thread 对象所对应的方法 run() 来完成其操作的，方法 run() 称为线程体。通过调用 Thread 类的 start() 方法来启动一个线程。

public class MyThread extends Thread{
    private String name;

    public MyThread(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        for(int x = 0; x < 10; x++){
            System.out.println(this.name + "-->" + x);
        }
    }
}

启动多线程

public class Demo {
    public static void main(String[] args) {
        MyThread a = new MyThread("线程A");
        MyThread b = new MyThread("线程B");
        MyThread c = new MyThread("线程C");
        a.start();
        b.start();
        c.start();
    }
}
结果：线程B-->0
	线程B-->1
	线程B-->2
	线程A-->0
	线程C-->0
	线程A-->1
	线程A-->2
	线程C-->1
	线程C-->2

通过Runnable接口来创建线程

public class MyThread implements Runnable{
    private String name;

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

    @Override
    public void run() {
        for(int x = 0; x < 3; x++){
            System.out.println(this.name + "-->" + x);
        }
    }
}

利用Thread类启动多线程

public class Demo {
    public static void main(String[] args) {
        MyThread a = new MyThread("线程A");
        MyThread b = new MyThread("线程B");
        MyThread c = new MyThread("线程C");
        new Thread(a).start();
        new Thread(b).start();
        new Thread(c).start();
    }
}

线程状态

线程转换状态
在这里插入图片描述
创建状态
在程序中用构造方法创建了一个线程对象后, 新的线程对象便处于新建状态,此时，它已经有了相应的内存空间和其它资源,但还处于不可运行状态。新建一个线程对象可采用Thread类的构造方法来实现， 例如: Thread thread=new Thread();

就绪状态
新建线程对象后，调用该线程的start()方法就可以启动线程。当线程启动时，线程进入就绪状态。此时，线程将进入线程队列排队，等待CPU服务, 这表明它已经备了运行条件。

运行状态
当就绪状态的线程 被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象的run()方法。run()方法定 义了该线程的操作和功能。

堵塞状态
一个正在执行的线程在某些特殊情况下， 如被人为挂起或需要执行耗时的输入输出操作时，将让出CPU并暂时中止自己的执行，进入堵塞状态。在可执行状态下,如果调用sleep()、suspend()、 wait()等方法, 线程都将进入堵塞状态。堵塞时，线程不能进入排队队列，只有当引|起堵塞的原因被消除后,线程才可以转入就绪状态。

终止状态
线程调用stop()方法时或run()方法执行结束后，线程即处于终止状态。处于终止状态的线程不具有继续运行的能力。

多线程常用操作方法

线程的命名与取得

由于多线程的状态不确定，所以线程的名字就成为了唯一的分辨标识。取得当前线程对象的方法为：public static Thread currentThread()
线程名称操作

NO.方法类型描述
1public Thread(Runnable target, String name)构造实例化线程对象，接收Runnable 接口子类对象，同时设置线程名称
2pubilc final void setName(String name)普通设置线程名称
3public final void getName()普通取得线程名称
class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
public class App {

    public static void main( String[] args )  {
        MyThread mt = new MyThread();
        new Thread(mt,"线程A").start();
        new Thread(mt,"线程B").start();
    }
}
结果：线程A
	线程B

线程休眠

线程的休眠指的是让程序的执行速度变慢一些。
方法为：public static native void sleep(long millis) throws InterruptedException;单位是毫秒

class MyThread implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName());
    }
}
public class App {

    public static void main( String[] args )  {
        MyThread mt = new MyThread();
        new Thread(mt,"线程A").start();
    }
}
结果：线程A

线程优先级

在java的线程操作中，哪个线程的优先级高，哪个线程就有可能会先被执行。
线程优先级操作

NO.方法或常量类型描述
1public final static int MAX_PRIORITY常量最高优先级，值为10
2public final static int NORM_PRIORITY常量中等优先级，值为5
3public final static int MIN_PRIORITY常量最低优先级，值为1
4public final void setPriority(int newPriority)普通设置线程优先级
5public final int getPriority()普通取得线程优先级
class MyThread implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName());
    }
}
public class App {

    public static void main( String[] args )  {
        MyThread mt = new MyThread();
        Thread t1 = new Thread(mt,"线程A");
        Thread t2 = new Thread(mt,"线程B");
        t2.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
    }

线程同步与死锁

➢同步是多线程开发中的一个重要概念, 但是既然有同步,那么就一定会存在有不同步的操作。所以本节将为读者分析线程不同步所带来的影响。

➢多个线程操作同一资源时就有可能出现不同步的问题，例如，现在产生N个线程对象实现卖票操作，同时为了更加明显的观察到不同步所带来的问题，所以本程序将使用线程的休眠操作。

线程同步

同步问题的引出

class MyThread extends Thread{

    private int ticket = 5;

    private String name;

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

    @Override
    public void run() {
        for(int x = 0; x < 50; x++){
            if(ticket > 0){
                System.out.println(this.name+ "卖票，ticket = " + ticket--);
            }
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        MyThread a = new MyThread("线程A");
        MyThread b = new MyThread("线程B");
        MyThread c = new MyThread("线程C");
        a.start();
        b.start();
        c.start();

    }
}
结果：线程A卖票，ticket = 5
	线程A卖票，ticket = 4
	线程A卖票，ticket = 3
	线程A卖票，ticket = 2
	线程A卖票，ticket = 1
	线程C卖票，ticket = 5
	线程C卖票，ticket = 4
	线程C卖票，ticket = 3
	线程B卖票，ticket = 5
	线程B卖票，ticket = 4
	线程B卖票，ticket = 3
	线程B卖票，ticket = 2
	线程B卖票，ticket = 1
	线程C卖票，ticket = 2
	线程C卖票，ticket = 1

➢如果想解决以上程序的问题,就必须使用同步,所谓的同步就是一个代码块中的多 个操作在同一个时间段内只能有一个线程进行， 其他线程要等待此线程完成之后才可以继续执行
在这里插入图片描述
使用同步方法解决问题

class MyThread implements Runnable{
    private int ticket = 5;

    @Override
    public void run() {
        for(int x = 0; x < 20; x++){
            sale();
        }
    }
    public synchronized void sale(){
        if(ticket > 0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"卖票，ticket = " + ticket--);
        }
    }
}
public class App {
    public static void main( String[] args )  {
        MyThread mt = new MyThread();
        Thread t1 = new Thread(mt,"线程A");
        Thread t2 = new Thread(mt,"线程B");
        t1.start();
        t2.start();
    }
}
结果：线程A卖票，ticket = 5
	线程A卖票，ticket = 4
	线程A卖票，ticket = 3
	线程A卖票，ticket = 2
	线程B卖票，ticket = 1

死锁

➢同步就是指一个线程要等待另外一个线程执行完毕才会继续执行的一种操作形式,虽然在一个程序中，使用同步可以保证资源共享操作的正确性,但是过多同步也会产生问题。例如:现在有张三想要李四的画，李四想要张三的书,那么张三对李四说了: “把你的画给我，我就给你书”，李四也对张三说了: “把你的书给我,我就给你画”，此时，张三在等着李四的答复,而李四也在等着张三的答复,那么这样下去最终结果可想而知，张三得不到李四的画, 李四也得不到张三的书，这实际上就是死锁的概念

线程的生命周期

在java中，一个线程对象也有自己的生命周期，如果要控制好线程的生命周期，首先应该认识生命周期。
停止线程运行

class MyThread implements Runnable{
    private boolean flag = true;

    @Override
    public void run() {
        while (this.flag){
            System.out.println(Thread.currentThread().getName());
        }
    }
    public void stop(){
        this.flag = false;
    }
}
public class App {

    public static void main( String[] args )  {
        MyThread mt = new MyThread();
        Thread t1 = new Thread(mt,"线程A");
        t1.start();
        mt.stop();
    }
}
茉莉915
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程进程和线程之由来Java开发Java经验技
11-22
Java并发编程是Java开发中的重要领域，涉及到进程与线程的概念，这两个概念是理解多任务执行的基础。在现代计算机系统中，进程和线程被广泛用于实现高效的资源管理和任务调度。 **1. 进程** 进程是操作系统分配...
java 线程详解及线程与进程的区别
08-31
Java线程详解与进程的区别是理解多任务并发执行的关键。在计算机系统中，进程和线程是两种不同的执行单元。 1. **进程**：每个进程都有独立的内存空间，这意味着不同进程之间的数据不能直接共享。例如，当你打开多...
Java多线程看我这一篇就足够了
探索者李小白的博客
09-18 5082
通过本篇的学习你可以掌握以下内容： 了解进程与线程的区别。 掌握Java多线程的两种实现方式及区别。 了解线程的状态变化。 了解多线程的主要操作方法 。 了解同步及死锁的概念。 了解线程的生命周期。 进程与线程进程是程序的一次动态执行过程，它需要经历从代码加载，代码执行到执行完毕的一个完整的过程，这个过程也是进程本身从产生，发展到最终消亡的过程。多进程操作系统能同时达运行多个进程（程序），由于CPU
安卓第七节课
Ye_RenYang的博客
07-06 80
标题线程的基本用法 Android多线程编程其实并不比Java多线程编程特殊，基本都是使用相同的语法。比如说，定义一个线程只需要新建一个类继承自Thread,然后重写父类的run()方法，并在里面编写耗时逻辑即可，如下所示: class MyThread extends Thread { @0verride public void run() { //处理具体的逻辑 } 那么该如何启动这个线程呢?其实也很简单，只需要new出MyThread的实例，然后调用它的start()方法，这样run()方法中的代码就
多线程（三） —— 同步与死锁
冬冬466的博客
09-06 174
了解线程同步的作用          一个多线程的程序，如果是通过Runnable接口实现的，则意味着类中的属性将被多个线程共享，那么这样一来就会造成一种问题，如果这多个线程要操作同一资源的时候就有可能出现资源的同步问题。例如：以之前的卖票程序来讲，如果多个线程同时操作的时候就有可能出现卖出票为负数的问题。 package com.dong1990; public class fifth ...
9. 多线程 Part 3 同步与死锁 --- 学习笔记
forfan06的专栏
07-02 445
 9.6 同步与死锁       9.6.1 问题的产生       9.6.2 使用同步解决问题       9.6.3 死锁 9.7 线程操作案例 --- 生产者及消费者       9.7.1 程序的基本实现       9.7.2 问题的解决方法1 --- 加入同步       9.7.3 Object类对线程的支持  ---  等待与唤醒       9.
多线程面试题
m0_61218014的博客
08-12 450
解决方法很简单，一是用synchronized这种内置锁，二是用AtomicInteger这样的concurrent包里封装好的元素，简洁起见我用第二种实现如下： 饿汉式：在类初始化时就直接创建单例对象，而类初始化过程是没有线程安全问题的形式一： 形式二： 测试类： 懒汉式：延迟创建对象，第一次调用getInstance方法再创建对象形式一： 形式二： 7.Java中的notify和notifyAll有什么区别 8.为什么wait和notify方法要在同步块中调用 案例：有家餐馆的取餐口比较小，只能放1
线程与进程，你真得理解了吗
云深不知处
05-07 12万+
相信大家面试时一定没少被一个问题刁难，那就是进程和线程的区别是什么？这个问题延申开来并不像表面那么简单，今天就来深入一探。 开始前先看一组非常传神的图例，相信可以帮助你更好理解进程与线程的概念： 1 进程与线程的关系和区别 什么是进程 进程可以说是一个“执行中的程序”。程序是指令、数据及其组织形式的描述，是一个没有生命的实体，只有处理器赋予程序生命时（操作系统执行之），它才能成为一个活动的实体，我们称其为进程。 进程有哪些特征？ 进程依赖于程序运行而存在，进程是动态的，程序是静态的； 进程是操作系统进行
java的进程和线程_java进程和线程区别与不同
weixin_35586996的博客
02-20 2713
java进程和线程区别与不同。一、定义1.进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，是系统进行资源分配和调度的一个独立单位。2.线程是进程的一个实体，是CPU调度和分派的基本单位，他是比进程更小的能独立运行的基本单位，线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源(如程序计数器，一组寄存器和栈)，一个线程可以创建和撤销另一个线程；进程和线程的关系：(1)一个线程...
JAVA进程和线程
程序猿追的博客
11-06 8756
进程就是正在运行的程序，它是系统资源调度的独立单位，并且一个进程可以执行多个任务，而线程就是程序执行的任务，它是程序使用CPU的基本单位，因此也可以说线程是依赖于进程的。像比如任务管理器里面的运行任务就是线程。
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 41万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
mgbqhol.zip_进程与线程_Java_
08-10
在Java编程领域，进程与线程是两个非常重要的概念，它们是操作系统中并行处理任务的基本单位。在本文中，我们将深入探讨这两个概念以及它们在Java中的应用。 首先，我们来理解什么是进程。进程可以被定义为一个正在...
bank.rar_进程与线程_Java_
08-12
总的来说，理解和应用进程与线程是Java程序员必备的技能之一。通过分析银行账户的存取款线程设计，我们可以深入学习并发编程的原理和实践，这对于开发高并发、高性能的应用程序非常重要。这个示例项目提供了一个很好...
downloadDemo.rar_进程与线程_Java_
08-11
在Java编程中，进程与线程是两个非常重要的概念，它们是操作系统中资源管理和执行的基本单位。本示例"downloadDemo.rar"是一个关于Java多线程下载的实践案例，通过并发线程实现高效的文件下载。 首先，我们来理解...
算机科学与技术 基于Java的医务室病例管理小程序的设计与实现.docx
07-20
算机科学与技术 基于Java的医务室病例管理小程序的设计与实现
物联网工程_基于NBIOT的白洋淀水质实时监测系统.docx
07-20
物联网工程_基于NBIOT的白洋淀水质实时监测系统
国企数字化转型解读及赋能三套材料.pptx
07-20
国企数字化转型解读及赋能三套材料.pptx
搞金融的同学三小时快速入门python从零入门量化交易系列.doc
最新发布
07-20
Python
某国字头央企市场化与数字化转型(交付版).pptx
07-20
某国字头央企市场化与数字化转型(交付版).pptx

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值