Java 多线程(一)

最新推荐文章于 2024-08-16 23:08:28 发布
最新推荐文章于 2024-08-16 23:08:28 发布
阅读量207 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iwanttostudyok/article/details/127123282
版权

人之所以能，是相信自己能！

1、什么是进程？

简单来说：一个正在运行的应用程序就相当于一个线程

2、什么是线程？

线程是：一个进程中的执行场景/执行单元。

一个进程可以启动多个线程

对于java程序来说，当在DOS命令窗口中输入：
java HelloWorld 回车之后。会先启动JVM，而JVM就是一个进程。

JVM再启动一个主线程调用main方法（main方法就是主线程）。
同时再启动一个垃圾回收线程负责看护，回收垃圾。

最起码，现在的java程序中至少有两个线程并发，一个是 垃圾回收线程，一个是 执行main方法的主线程。

3、进程和线程是什么关系？

在java语言中：

线程A和线程B，堆内存 和 方法区 内存共享。但是 栈内存 独立，一个线程一个栈。

简单举例:

火车站，可以看做是一个进程。
火车站中的每一个售票窗口可以看做是一个线程。
我在窗口1购票，你可以在窗口2购票，你不需要等我，我也不需要等你。所以多线程并发可以提高效率。

思考问题:

使用了多线程机制之后，main方法结束，是不是有可能程序也不会结束？

main方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在压栈弹栈。

4、关于线程对象的生命周期？★★★★★

  1. 新建状态
  2. 就绪状态
  3. 运行状态
  4. 阻塞状态
  5. 死亡状态

5、实现线程的四种方式

  1. 继承Thread类
  2. 实现Runnable接口
  3. 实现 Callable 接口
  4. 创建线程池

我主要说我开发中常用的两种方式:

  一、继承Thread类

通过继承 Thread 类实现多线程的步骤如下：

创建 MyThread 类，让其继承 Thread 类并重写 run() 方法。
创建 MyThread 类的实例对象，即创建一个新线程。
调用 start() 方法，启动线程。

public class ThreadTest02 {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        // 启动线程
        //t.run(); // 不会启动线程，不会分配新的分支栈。（这种方式就是单线程。）
        t.start();
        // 这里的代码还是运行在主线程中。
        for(int i = 0; i < 1000; i++){
            System.out.println("主线程--->" + i);
        }
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        // 编写程序，这段程序运行在分支线程中（分支栈）。
        for(int i = 0; i < 1000; i++){
            System.out.println("分支线程--->" + i);
        }
    }
}

 

注意：

t.run() 不会启动线程，只是普通的调用方法而已。不会分配新的分支栈。（这种方式就是单线程。）

t.start() 方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。
这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。线程就启动成功了。
启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。
run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main是平级的。

二、实现 Runnable 接口(个人比较推荐这种方式原因下面会讲)

通过实现 Runnable 接口实现多线程的步骤如下：

创建 MyRunnable 类实现 Runnable 接口。
创建 MyRunnable 类的实例对象 myRunnable 。
把实例对象 myRunnable 作为参数来创建 Thread 类的实例对象 thread，实例对象 thread 就是一个新线程。
调用 start() 方法，启动线程。
 

示例代码:

public class ThreadTest03 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable()); 
        // 启动线程
        t.start();
        
        for(int i = 0; i < 100; i++){
            System.out.println("主线程--->" + i);
        }
    }
}

// 这并不是一个线程类，是一个可运行的类。它还不是一个线程。
class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            System.out.println("分支线程--->" + i);
        }
    }
}

采用匿名内部类创建：

public class ThreadTest04 {
    public static void main(String[] args) {
        // 创建线程对象，采用匿名内部类方式。
        Thread t = new Thread(new Runnable(){
            @Override
            public void run() {
                for(int i = 0; i < 100; i++){
                    System.out.println("t线程---> " + i);
                }
            }
        });

        // 启动线程
        t.start();

        for(int i = 0; i < 100; i++){
            System.out.println("main线程---> " + i);
        }
    }
}

注意：
第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其它的类，更灵活。

其他两种创建线程的方式，大家可以自行百度，哈哈！

6、获取当前线程对象、获取线程对象名字、修改线程对象名字

方法名作用
static Thread currentThread()获取当前线程对象
String getName()获取线程对象名字
void setName(String name)修改线程对象名字

7、关于线程的sleep方法

static void sleep(long millis)让当前线程休眠millis秒

静态方法：Thread.sleep(1000);
参数是毫秒
作用： 让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其它线程使用。
这行代码出现在A线程中，A线程就会进入休眠。
这行代码出现在B线程中，B线程就会进入休眠。
Thread.sleep()方法，可以做到这种效果：
间隔特定的时间，去执行一段特定的代码，每隔多久执行一次。
 

示例代码:

public class ThreadTest06 {
    public static void main(String[] args) {
    	//每打印一个数字睡1s
        for(int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName() + "--->" + i);

            // 睡眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

8、中断线程的方法

方法名作用
void interrupt()终止线程的睡眠

public class ThreadTest08 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable2());
        t.setName("t");
        t.start();

        // 希望5秒之后，t线程醒来（5秒之后主线程手里的活儿干完了。）
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 终断t线程的睡眠（这种终断睡眠的方式依靠了java的异常处理机制。）
        t.interrupt();
    }
}

class MyRunnable2 implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "---> begin");
        try {
            // 睡眠1年
            Thread.sleep(1000 * 60 * 60 * 24 * 365);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //1年之后才会执行这里
        System.out.println(Thread.currentThread().getName() + "---> end");
}

9、小知识点补充

为什么run()方法只能try…catch…不能throws？

因为run()方法在父类中没有抛出任何异常，子类不能比父类抛出更多的异常。

10、java中强行终止一个线程的执行（不推荐使用，了解即可！）

public class ThreadTest09 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable3());
        t.setName("t");
        t.start();

        // 模拟5秒
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 5秒之后强行终止t线程
        t.stop(); // 已过时（不建议使用。）
    }
}

class MyRunnable3 implements Runnable {

    @Override
    public void run() {
        for(int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName() + "--->" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

注意：

这种方式存在很大的缺点：容易丢失数据。

因为这种方式是直接将线程杀死了，线程没有保存的数据将会丢失。不建议使用。

11、Java中合理结束一个进程的执行

public class ThreadTest10 {
    public static void main(String[] args) {
        MyRunable4 r = new MyRunable4();
        Thread t = new Thread(r);
        t.setName("t");
        t.start();

        // 模拟5秒
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 终止线程
        // 你想要什么时候终止t的执行，那么你把标记修改为false，就结束了。
        r.run = false;
    }
}

class MyRunable4 implements Runnable {

    // 打一个布尔标记
    boolean run = true;

    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            if(run){
                System.out.println(Thread.currentThread().getName() + "--->" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                // return就结束了，你在结束之前还有什么没保存的。
                // 在这里可以保存呀。
                //save....

                //终止当前线程
                return;
            }
        }
    }
}

12、java中提供了哪些方法是和线程调度有关系的呢

方法名作用
int getPriority()获得线程优先级
void setPriority(int newPriority)设置线程优先级

  • 最低优先级1
  • 默认优先级是5
  • 最高优先级10

优先级比较高的获取CPU时间片可能会多一些。（不绝对!!,大概率）

13、yield方法

方法名作用
static void yield()让位方法，当前线程暂停，回到就绪状态，让给其它线程。

yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。

yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。

注意：在回到就绪之后，有可能还会再次抢到。

public class ThreadTest12 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable6());
        t.setName("t");
        t.start();

        for(int i = 1; i <= 10000; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

class MyRunnable6 implements Runnable {

    @Override
    public void run() {
        for(int i = 1; i <= 10000; i++) {
            //每100个让位一次。
            if(i % 100 == 0){
                Thread.yield(); // 当前线程暂停一下，让给主线程。
            }
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

注意： 并不是每次都让成功的，有可能它又抢到时间片了。

14、join方法

方法名作用
void join()将一个线程合并到当前线程中，当前线程受阻塞，加入的线程执行直到结束

class MyThread1 extends Thread {
	public void doSome(){
		MyThread2 t = new MyThread2();
		t.join(); // 当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以继续。
	}
}

class MyThread2 extends Thread{

}

第一篇先讲解些基础知识，下篇才是进入正题!!!!!!(且听下回解说!)

Everonward、
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java并发编程系列01:继承Thread类实现多线程
fen_fen的专栏
11-21 1764
多线程学习1-->继承Thread类实现多线程 Thread类本质上也是实现了Runnable接口的一个类，启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。 例如： class MyThread extends Thread{ private i
Java并发：创建线程的两种方法：继承Thread类和实现Runnable接口（一）
热门推荐
区块链之美
04-09 1万+
【1】了解进程与线程的概念 进程是一个程序在其自身的地址空间中执行一次活动，是资源申请、调度和独立运行的单位。 线程是进程中的一个单一的连续控制流程，一个进程可以包含一个或多个线程。 如果要在一个程序中实现多段代码同时交替运行，就需要产生多个线程，并指定每个线程上要运行的程序代码段，这就是多线程。 当程序运行时，就自动产生了一个线程，主函数main就是在这个线程上运行的，当不再产生新的线程时，...
Java 中 继承（extends) 的方法和理解
2301_76230288的博客
02-09 4667
Java中继承的方法
Java——多线程
m0_48936146的博客
05-16 1138
1、继承Thread类创建多线程 1.1 在学习多线程之前，先来看看单线程程序。 class Mythread{ public void run(){ for(int i=1;i<100;i++){ System.out.println("MyThread类的run()方法在运行"); i+=1; } } } public class Example01 { public static voi
Java中级-面向对象-继承（extends）
m0_60509400的博客
08-11 1307
Java中级-面向对象-继承
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
Java多线程下载器
09-26
Java多线程下载器是一种利用Java编程语言实现的高效文件下载工具，它通过将大文件分割成多个部分并同时下载，显著提高了下载速度。在Java中实现多线程下载器涉及许多关键概念和技术，包括线程、并发控制、网络I/O...
java 多线程
11-07
### Java多线程知识点详解 #### 一、Java Thread 概念 在Java中，**线程**是一种轻量级的进程，它是程序执行流的最小单元。一个标准的Java应用通常至少包含一个线程，即主（Main）线程。Java支持多线程编程，这...
325 继承Thread类的方式实现多线程
m0_63673788的博客
11-11 523
325继承Thread类的方式实现多线程 （查看帮助文档-Thread） 【多线程的实现方式】 方式1，继承Thread类 myThread类继承Thread类 在myThread类中，重写run方法 创建myThread类的对象 启动线程 Q1:为什么要重写run方法？ ——因为不是所有代码都要执行，为了区分需要执行的代码，所以重写 Q2：run方法和start方法的区别 ——run封装线程执行的代码，直接调用，相当于普通方法的调用，start启动线程，然后由JVM调用此线程的run.
java 线程 代码_Java线程代码的实现方法
weixin_34641420的博客
02-18 437
一、线程Java代码实现1.继承Thread声明Thread的子类public class MyThread extends Thread {public void run(){System.out.println("MyThread running");}}运行thread子类的方法MyThread myThread = new MyThread();myTread.start();2.创建Th...
java 多线程之 extends Thread
比嗨皮兔
01-05 1万+
线程的实现方式 java 多线程之 extends Thread java 多线程之 implements Runnable java 多线程之 implements Callable 线程池的使用 线程池简介 ThreadPoolExecutor java 线程池之 newScheduledTh......
java 多线程 Thread.run()和Thread.start()方法的区别
perfect_red的博客
08-02 337
  写一个Thread类： public class MyThread extends Thread { public MyThread(){ super(); System.out.println("构造函数执行:" + Thread.currentThread().getName()); } @Override publ...
编写MyThread类继承自Thread.创建MyThread类对象时可指定循环次数n.(Java)
spursping的博客
07-05 1978
package spurs_ping; import java.util.Scanner; /*编写MyThread类继承自Thread.创建MyThread类对象时可指定循环次数n. 功能:输出从0到n-1的整数.并在最后使用System.out.println(Thread.currentThread().getName打印标识信息 输入样例: 3 输出样例: 0 1 2 标识信息 */ class MyThread extends Thread{ int i; public MyThread(int
Thread
luplee的博客
11-24 1041
1、如何用Thread创建多线程？ class MyThread extends Thread{     private String name;         public MyThread(String name){         this.name = name;     }         publicvoid run(){//覆写Thread中的run()
JAVA进阶补充
2301_80150315的博客
08-15 737
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 525
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 884
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 261
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
Java多线程深度解析
《Java多线程详解》是一本全面介绍Java多线程编程的书籍，适合有一定Java基础并希望深入理解多线程的开发者阅读。通过学习，读者不仅能掌握多线程的基本概念和使用技巧，还能了解到如何在实际项目中高效、安全地利用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值