java多线程—入门

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量71 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55105017/article/details/131823499
版权

学习之前我们先了解一下什么是进程和线程。

进程：进程就是系统中正在运行的一个程序，程序一旦运行就是进程，每个进程都拥有独立的地址空间

线程：线程是进程的一个执行单元，一个进程可以有多个线程

举个例子 一个播放器 他可以有声音、图像、字幕 而这里播放器就相当于一个进程 声音、字幕、图像分别代表一个线程

线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止

在java中想要实现多线程，有三种手段，一种是继承Thread类，一种是实现Runnable接口 还有一种是实现Callable接口 其实最常见的就是第一种和第二种，第三种只是作为了解 创建线程还有第四种使用线程池创建、第五种使用匿名类也就是Lambda表达式 java 8的新特性

后三种可以作为了解。

一、继承Thread类

继承Thread类是比较常用的一种方式，你如果只想起一条线程的话 就可以使用Thread

public class TestThread1 extends Thread{
    private String name;

    public TestThread1(String name) {
        this.name=name;
    }
    @Override
    public void run() {
        // run方法线程体
        for (int i = 0; i < 5; i++) {
            System.out.println(name+"运行："+i);
        }
    }

    public static void main(String[] args) {

        TestThread1 testThread1=new TestThread1("奥特曼");
        TestThread1 testThread2=new TestThread1("怪兽");
        // 调用start方法开启线程
        testThread1.start();
        testThread2.start();


    }
}

输出：

奥特曼运行：0
怪兽运行：0
奥特曼运行：1
奥特曼运行：2
奥特曼运行：3
奥特曼运行：4
怪兽运行：1
怪兽运行：2
怪兽运行：3
怪兽运行：4

可以看到这两个线程是同时进行去抢资源运行 这里说明一下 程序启动运行main时候，java虚拟机就启动了一个进程 主线程main在main在被调用的时候创建，然后随着两个方法.start() 另外两个线程也被创建出来了

注意：start()方法的调用后并不是立即执行多线程代码，而是使得该线程变为就绪状态，什么时候运行就要看操作系统决定

Thread.sleep()方法是使线程进行休眠 目的就是不让某个线程霸占整个进程的cpu资源，流出一些时间给其他线程一个执行的机会

这里有个小知识点看一下 面试的时候有被问过整理一下：start()和run()的区别

run

首先呐 这个run方法是thread里的一个普通方法，直接调用run方法，这个时候他会运行在主线程中，这时候程序中依然只有主线程一个线程 程序执行路径还是只有一条 还是要按顺序执行，就是要等待run方法体执行完才可以继续执行代码，这样就没有达到一个多线程的目的。

start

使用start方法才是真正的实现了多线程运行，以为使用start方法不用等待run方法体代码执行完而是直接继续执行下面的代码，因为上面说过线程有五种阶段创建、就绪、运行、阻塞、终止，用Threar的start()方法来启动一个线程，此时这个线程处于就绪(可运行状态)，并没有运行，等cpu空闲时，才会执行线程里的run方法，run方法执行完毕 此线程结束

总结：run方法只是Thread里的一个普通方法 而start()方法才是真正的执行多线程

二、实现Runnable接口

Runnable也是一种比较常用的方式 这里我们只需要重写run方法即可

public class TestThread3 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+ "运行了：" + i);
        }
    }

    public static void main(String[] args) {
        // 创建线程对象 并启动
        new Thread(new TestThread3(),"怪兽").start();
        new Thread(new TestThread3(),"奥特曼").start();
    }
}

输出：

奥特曼运行了：0
怪兽运行了：0
奥特曼运行了：1
怪兽运行了：1
奥特曼运行了：2
奥特曼运行了：3
奥特曼运行了：4
怪兽运行了：2
怪兽运行了：3
怪兽运行了：4

注意：这里的Thread.currentThread().getName()是获取当前线程的名字，new Thread(new TestThread3(),"怪兽").start();此线程的名字

可以看到我们上面是使用的一个实现Runnable接口来创建的一个多线程，不管我们是继承Thread还是实现Runnable接口 他都会有一个run()方法体 这里run()方法是多线程程序的一个约定，所有的多线程代码都在run()方法里面，Thread类也是实现Runnable接口的类

三、Thread和Runnable的区别

讲完创建方式 来看看他们的区别吧 继承Thread 他不适合资源共享，但是如果实现Runnable接口，他就可以实现资源共享

那他是怎么进行资源共享的呐 来个简单的示例来看看吧

public class TestThread4 implements Runnable{

    // 票数
    private int ticketName = 10;

    @Override
    public void run() {
            while (true){
                if(ticketName<=0){
                    break;
                }
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketName--+"张票");
        }

    }

    public static void main(String[] args) {
        TestThread4 testThread4 = new TestThread4();

        new Thread(testThread4,"黄牛1").start();
        new Thread(testThread4,"黄牛2").start();
        new Thread(testThread4,"黄牛3").start();
    }
}

输出：

黄牛1-->拿到了第10张票
黄牛3-->拿到了第10张票
黄牛2-->拿到了第9张票
黄牛3-->拿到了第8张票
黄牛2-->拿到了第8张票
黄牛1-->拿到了第8张票
黄牛1-->拿到了第7张票
黄牛3-->拿到了第7张票
黄牛2-->拿到了第7张票
黄牛2-->拿到了第6张票
黄牛1-->拿到了第6张票
黄牛3-->拿到了第6张票
黄牛2-->拿到了第5张票
黄牛1-->拿到了第4张票
黄牛3-->拿到了第5张票
黄牛3-->拿到了第3张票
黄牛2-->拿到了第2张票
黄牛1-->拿到了第3张票
黄牛2-->拿到了第0张票
黄牛1-->拿到了第1张票
黄牛3-->拿到了第-1张票

进程已结束,退出代码0

一个简单的抢票示例，从上面输出可以看到10个票3个人抢实现了资源共享 但是输出中出现了一些问题下面的线程同步会讲解 这里是演示一下Runnable怎么资源共享的

总结一下：

实现Runnable接口比继承Thread类所具有的优势：

  1. 适合多个相同的程序代码的线程去处理同一个资源

  2. 增强程序的健壮性，代码可以被多个线程共享，代码和数据独立

  3. 避免了java中的单继承限制

  4. 线程池中只能放入实现Runnable或callable类的线程，不能直接放入继承Thread的类

三、Thread的常用方法

sleep()

上面已经讲了一个sleep()方法，他是取决于具体系统计时器和调度程序的精度和准确性

有两种方式

sleep(x) 一个参数时 表示休眠 ，x表示毫秒

sleep(x,y) 两个参数时 表示休眠 x毫秒又y纳秒

currentThread()

返回对当前正在执行的线程对象的引用，上面就是用这个方法获取到当前线程的名字 使用方法可以看上面的代码

start()

表示一个线程的开始，执行后java虚拟机调用该线程的run方法。

run()

Thread的普通方法 执行在主线程 需要等待run方法体执行完执行

还有很多大家可以自行百度了解

yield()

线程礼让， 让当前正在执行的线程暂停，但是不阻塞，将线程从运行状态转换为就绪状态 这里注意礼让不一定成功 这就要看cpu心情了

join()

join合并线程，待此线程执行完成后，在执行其他线程，其他线程阻塞

四、线程优先级

java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行

线程的优先级用数字表示 范围1~10

 可以在Thread类里看到这里有3个常量 最小的优先级为1 最大的优先级为10

这是Thread类里面的一个设置线程优先级的方法 if里面有一个判断 这个是判断 如果优先级大于最大值(10)并且小于最小值(1)会发生一个异常  

public class TestThread6 {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());

        Mypriority mypriority = new Mypriority();

        Thread t1 = new Thread(mypriority, "t1");
        Thread t2 = new Thread(mypriority, "t2");
        Thread t3 = new Thread(mypriority, "t3");

        t1.setPriority(10);
        t1.start();

        t2.setPriority(4);
        t2.start();

        t3.setPriority(1);
        t3.start();
    }

}

class Mypriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());
    }
}

输出：

main-->5
t1-->10
t2-->4
t3-->1

可以看到打印出来的优先级 注意：要先设置优先级 再启动线程 我们可以使用setPriority()设置优先级 getPriority()获取优先级

五、线程同步

这里需要先熟悉synchronized 它是java中的一个关键字 是一种同步锁 它修饰的对象有一下几种

1.修饰代码块，被修饰的代码块称为同步语句块，主要作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象

2.修饰方法，被修饰的方法称为同步方法，其作用是整个方法 作用的对象是调用这个方法的对象

3.修饰静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象

4.修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象

我们可以将上面抢票的示例拿过来看看

public class TestThread4 implements Runnable{
// 票数
private int ticketName = 10;

@Override
public void run() {
        while (true){
            if(ticketName<=0){
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketName--+"张票");
    }

}

public static void main(String[] args) {
    TestThread4 testThread4 = new TestThread4();

    new Thread(testThread4,"黄牛1").start();
    new Thread(testThread4,"黄牛2").start();
    new Thread(testThread4,"黄牛3").start();
    }
}

输出：

黄牛1-->拿到了第10张票
黄牛3-->拿到了第10张票
黄牛2-->拿到了第9张票
黄牛3-->拿到了第8张票
黄牛2-->拿到了第8张票
黄牛1-->拿到了第8张票
黄牛1-->拿到了第7张票
黄牛3-->拿到了第7张票
黄牛2-->拿到了第7张票
黄牛2-->拿到了第6张票
黄牛1-->拿到了第6张票
黄牛3-->拿到了第6张票
黄牛2-->拿到了第5张票
黄牛1-->拿到了第4张票
黄牛3-->拿到了第5张票
黄牛3-->拿到了第3张票
黄牛2-->拿到了第2张票
黄牛1-->拿到了第3张票
黄牛2-->拿到了第0张票
黄牛1-->拿到了第1张票
黄牛3-->拿到了第-1张票

这里黄牛1和黄牛3同时抢到10张票 这非常不合理 怎么一人一半？还有黄牛3还抢到了-1票 多个线程操作同一个资源发现了问题 这里我们就需要他们排队一个一个来

public class TestThread4 implements Runnable{

    // 票数
​    private int ticketName = 10;
​    private boolean flag = true;

​    @Override
​    public void run() {
​            while (true){
​                try {
​                    Thread.*sleep*(200);
​                } catch (InterruptedException e) {
​                    throw new RuntimeException(e);
​                }
​               buy();
​            }

​    }

​    public synchronized void buy(){
​        if(ticketName<=0){
​            flag=false;
​            return;
​        }
​        System.*out*.println(Thread.*currentThread*().getName()+"-->拿到了第"+ticketName--+"张票");
​    }

​    public static void main(String[] args) {
​        TestThread4 testThread4 = new TestThread4();

​        new Thread(testThread4,"黄牛1").start();
​        new Thread(testThread4,"黄牛2").start();
​        new Thread(testThread4,"黄牛3").start();
​    }
}

输出：

黄牛1-->拿到了第10张票
黄牛2-->拿到了第9张票
黄牛3-->拿到了第8张票
黄牛3-->拿到了第7张票
黄牛1-->拿到了第6张票
黄牛2-->拿到了第5张票
黄牛3-->拿到了第4张票
黄牛2-->拿到了第3张票
黄牛1-->拿到了第2张票
黄牛2-->拿到了第1张票

输出就不一样了，这里我修饰的是一个buy()方法 同步方法 注意synchronized锁的是一个增删改的一个对象

同步块：synchronized（Obj）{} Obj可以是任何对象，但是推荐使用共享资源作为同步监视器

六、其他线程创建方式

继承Callable类

public class TestThread7 implements Callable {
    @Override
    public Object call() throws Exception {
        int sum=0;

        for (int i = 0; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum+=i;
            }
        }
        return sum;
    }

    public static void main(String[] args) {
        TestThread7 testThread7=new TestThread7();

        //创建FutureTask对象 将callable对象传递到FutureTask构造器中
        FutureTask futureTask=new FutureTask(testThread7);

        new Thread(futureTask).start();

        Object o = null;
        try {
            o = futureTask.get();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
        System.out.println("总和为:"+o);
    }
}

  • call()可以有返回值的

  • call()可以抛出异常，被外面的操作捕获，获取异常的信息

  • Callable是支持泛型的

使用线程池

public class TestThread8{
    public static void main(String[] args) {
        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.execute(new Test1());
        executorService.execute(new Test2());

        executorService.shutdown();
    }
}
class Test1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

class Test2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

使用匿名类

public class TestThread8{
    public static void main(String[] args) {
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("子线程开始执行");
            }
        });
        thread.start();
    }
}

或者这样

new Thread(()->{
            System.out.println("子线程开始执行");
        }).start();

纯纯小白，有什么要注意的地方 请大佬指点一下，谢谢

LLL学技术
关注
java多线程入门
06-13
### Java多线程入门 #### 一、进程与线程的区别 在理解Java中的多线程之前，我们先来看看进程和线程之间的区别。 - **进程**：进程是程序的一次执行过程，它是系统进行资源分配和调度的一个独立单位。每个进程都...
JAVA多线程入门基础知识
02-22
必知必会的多线程入门基础知识
Java 多线程入门
qq_43164662的博客
11-22 496
Java 多线程入门，了解多个线程是如何同时进行的。
Java多线程入门超详解(小白也可以看懂的）
qq_41257358的博客
05-10 3067
Java多线程入门超详解(小白也可以看懂的 一、名词详解1.1 进程和线程1.2 并行和并发1.3 同步和异同步1.4 临界资源和临界区二、为什么要用多线程三、线程的五种状态四、Java创建线程的两种方法1、继承Thread类2、实现Runnable接口五、Java线程的常用方法1、wait()和notify()2、sleep()，yield()，join()3、setPriority()六、sy...
java多线程入门例子-第一例
java 菜鸟一枚
09-18 3219
– 认识多线程-1 多线程运行顺序基础举例 多线程数据共享基本例子
Java多线程详解（一）Java多线程入门
刘成
11-27 2288
最近听很多面试的小伙伴说，网上往往是一篇一篇的Java多线程的文章，除了书籍没有什么学习多线程的一系列文章。但是仅仅凭借一两篇文章很难对多线程有系统的学习，而且面试的时候多线程这方面的知识往往也是考察的重点，所以考虑之下决定写一系列关于Java多线程的文章。文章参考了高老师的《Java多线程编程核心技术》。力争使用最短的篇幅把Java多线程的知识作以系统的讲述。 本节思维导图： 思维导图...
Java多线程入门(二)
qq_44525150的博客
06-07 2076
本文简要介绍了Java多线程中的线程同步的作用，实现线程同步的三种方法，什么是线程死锁，线程死锁的例子，线程的状态，线程的生命周期
JAVA多线程使用,从入门到精通,看这一篇打开思路,豁然开朗
yyj12138的博客
01-30 832
java多线程;线程创建;线程池;线程池参数;面试八股文;java创建线程的方式;多线程入门;多线程看这一篇就够了
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 42万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Java多线程入门篇（三）Java线程间的通信（锁，等待/通知，信号量，管道）
wangdawei_的博客
02-28 846
java多线程入门篇 （三） 锁与同步等待/通知机制信号量：管道：其它通信相关join方法sleep方法ThreadLocal类InheritableThreadLocal   在Java中合理的使用多线程可以更好的利用服务器资源。一般来说，线程都有自己的自由线程上下文，互不干扰。但是当我们需要多个线程之间互相协作的时候，就需要掌握Java线程的通信方式才可以 锁与同步   在Java中锁都是基于对象的，所以又称为对象锁。锁与线程的关系就像婚姻关系，一个锁在同一时间只能由一个线程持有，只有当持有锁的线程释放
002-Java多线程入门学习
qq_40488788的博客
11-24 342
Java多线程入门学习 ​ 狂神说Java多线程模块总结篇-凡人就该保留偏执的权利-kxd@my.swjtu.edu.cn 一.线程，进程，多线程 程
编程必备：JAVA多线程详解
拾一二的博客
06-14 8621
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
java多线程入门知识及示例程序
09-04
"Java多线程入门知识及示例程序" Java多线程是一种非常重要的编程技术，它可以帮助开发者创建高效、可扩展的程序。多线程的出现是为了解决某些问题，如图形界面的出现、输入、输出的阻塞和多核CPU的更好利用等。 ...
java多线程入门的源代码
03-28
Java多线程是Java开发中的重要概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：继承Thread类和实现Runnable接口。 1. 继承Thread类： 当一个类继承了Thread...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 142
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 817
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 881
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
基于Mysql、JavaScript、PHP、ajax开发的MBTI性格测试网站（前端+后端）
2302_79553009的博客
10-29 1443
本项目旨在构建一个基于MBTI（迈尔斯-布里格斯性格分类指标）理论的在线平台——“16Personalities”。该平台利用PHP、MySQL、JavaScript等技术栈开发，旨在帮助用户更好地理解和运用MBTI理论来评估个人性格类型，并应用于职业规划、团队建设和人际交往等多个方面。用户端功能 包括账号注册与登录、在线性格测试、性格类型浏览、团队评估及在线交友等模块。用户可以通过完成性格测试来获得详细的MBTI性格分析，并通过平台提供的功能与其他具有不同性格类型的用户互动。
SpringSession源码分析
lkr_lkr的博客
11-01 257
默认对常规Session的理解和使用，如何使用Set-Cookie。
Java多线程入门与线程安全
"这篇资料是关于Java多线程的学习材料，由高级软件人才实作培训专家北京传智播客教育提供，由讲师毕向东讲解。资料涵盖了多线程的基础概念，如进程、线程的创建与状态，以及线程安全问题和同步机制。" Java多线程是...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值