java中的线程

最新推荐文章于 2024-06-27 17:55:39 发布
最新推荐文章于 2024-06-27 17:55:39 发布
阅读量121 收藏
点赞数
分类专栏： JavaSE 文章标签： java thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ganfanqiang/article/details/106899923
版权

一、Thread

1、常用方法

  • void start()：启动线程，并执行对象的run()方法

  • run()：线程在被调度时执行的操作

  • String getName()：返回线程的名称

  • void setName(String name)：设置该线程名称

  • static Thread currentThread()：返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类

  • static void yield()：线程让步
      暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
     若队列中没有相同优先级的线程，忽略此方法

  • join()：当某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，知道join()方法加入的join线程执行完为止
     低优先级的线程也可以获得执行

  • static void sleep(long millis)：（指定时间：毫秒）
     令当前活动线程在指定时间段内放弃对CPU控制，使其他线程有机会被执行，时间到后重新排队
     抛出InterruptedException异常

  • stop()：强制线程生命期结束，已过时的方法

  • boolean isAlive()：返回boolean，判断线程是否还活着

2、优先级
  • 线程的优先等级
     MAX_PRIORITY：10
     MIN_PRIORITY：1
     NORM_PRIORITY：5 默认优先级
  • 涉及的方法
     getPriority()：返回线程优先值
     setPriority(int newPriority)：改变线程的优先级
  • 说明
     线程创建时继承父线程的优先级
     低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

二、线程的生命周期

JDK中用Thread.State类定义了线程的几种状态
要想实现多线程，必须在主线程中创建新的线程对象。java语言使用Thread类及其子类的对象来表示线程，在它的一个完整额生命周期中通常要经历如下五种状态：

  1. 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
  2. 就绪：处于新建状态的线程被start()后，将进入线程队列等待的CPU时间片，此时它已具备了运行的条件只是没分配到CPU资源
  3. 运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run()方法定义了线程的操作和功能
  4. 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
  5. 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
    生命周期流程图

三、线程的安全问题（同步处理）

出现情况：当多个线程共用时，出现了线程进入判断语句阻塞的问题，导致共享数据没及时操作，而出现的问题
 例：买票时，还剩下一张票，当某个线程未完成操作（已经进入关键代码的同时），另一线程完成了操作，而此时未完成的线程继续完成，就会导致多卖出了一张相同的票。

解决想法：当一个线程正在进行关键代码的操作时，其他线程不能进入，只有等上一线程完成后，才可进入关键代码的操作。

方式一：同步代码块
synchronized(同步监视器){
	//需要被同步的代码（关键代码）
}

说明：

  1. 操作共享数据的代码即为关键代码
  2. 共享数据：多个线程共同操作的数据
  3. 同步监视器，俗称：锁。任何一个类的对象都可以充当锁。要求：多个线程必须共用同一个锁

注意：操作关键代码时，处理的代码不要多余，更不要少于。
   在实现Runnable接口创建多线程时，可以考虑使用this充当同步监视器。不过继承Thread类创建多线程时，慎用this。但是可以尝试使用当前类作为同步监视器。如：

synchronized(Thread.class){}
方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明为同步的

说明：

  1. 同步方法任然涉及到同步监视器，只是不需要我们显式的声明
  2. 非静态的同步方法，同步监视器是this
    静态的同步方法，同步监视器是当前类本身

使用同步的方式的问题

  1. 好处：解决了线程的安全问题。
  2. 坏处：操作同步代码时只能有一个线程参与，其他线程等待，相当于是一个单线程的过程。
方式三：锁（lock）
  • 从JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能一个线程对Lock对象加锁，线程开始访问共享资源之前应当先获得Lock对象。
  • ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制送，比较常用的是ReentrantLock，可以显式加锁、释放锁。
ReentrantLock lock = new ReentrantLock();
//ReentrantLock lock = new ReentrantLock(true);让同步序列为队列方式
public void run(){
	try{
	//调用加锁
		lock.lock();
		//需要被同步的代码（关键代码）
	}finally{
	//调用解锁
		lock.unlock();
	}	
}

synchronized与Lock的异同：
相同：二者都可以解决线程安全问题
不同：synchronized机制在执行完相应的同步代码后，自动释放同步监视器，Lock需要手动开启同步（lock()），结束时也需要手动关闭同步（unlock()）。

四、线程的创建

1、继承Thread类：同步方法实现线程安全
/**
 * 创建多线程的第一种方式：继承Thread类
 * 实现三个进程同时出票
 */
public class Thread01 {
    public static void main(String[] args) {
        MyThread01 myThread01 = new MyThread01();
        MyThread01 myThread02 = new MyThread01();
        MyThread01 myThread03 = new MyThread01();

        myThread01.setName("线程一");
        myThread02.setName("线程二");
        myThread03.setName("线程三");
        //启动当前线程，调用当前线程的run()
        myThread01.start();
        myThread02.start();
        myThread03.start();
    }
}
/**
 * 继承Thread，重写run()
 * run()中为当前线程的执行内容。
 * 通过主方法main()实例化继承Thread的类，调用start()开启线程。
 */
class MyThread01 extends Thread{
    private static int number = 100;
    @Override
    public void run() {
        while (true){
            show();
            if (number == 0)
                break;
        }
    }
    private static synchronized void show(){
        if (number > 0) {
//            try {
//                Thread.sleep(100);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
            System.out.println(Thread.currentThread().getName() + ":" + number);
            number--;
        }
    }
}
2、实现Runnable接口：同步代码块实现线程安全
/**
 * 创建多线程的方式二：实现Runnable接口
 * 实现三个进程同时出票
 */
public class Thread02 {
    public static void main(String[] args) {
        MyThread02 m2 = new MyThread02();

        //通过Thread类的构造器创建线程
        Thread t1 =  new Thread(m2);
        Thread t2 =  new Thread(m2);
        Thread t3 =  new Thread(m2);

        t1.setName("线程一");
        t2.setName("线程二");
        t3.setName("线程三");

        t1.start();
        t2.start();
        t3.start();
    }
}
class MyThread02 implements Runnable{
    private int number = 100;
    @Override
    public void run() {
        while (true){
            synchronized (this) {
                if (number > 0) {
//                    try {
//                        Thread.sleep(200);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number--;
                } else {
                    break;
                }
            }
        }
    }
}

方式1、2之间的区别：

  • 方式一为继承Thread类，每次开启线程都需要实例化一个对象，所以子类的属性都是每一个对象独有的。所以方式一最后出来的结果为三个100的数。若想实现共用一个100的数，则创建的属性number需设置为静态的。
  • 方式二是实现Runnable接口，实现类只实例化一次，创建线程时，是通过Thread类的构造器实现的。所以例子中创建的三个线程共用一个100的数

说明：方式1、2为JDK5之前的创建方式；方式3、4为JDK5之后新增。

3、实现Callable接口：锁（lock）方式实现线程安全

与实现Runnable接口相比，实现Callable的优势在于：

  1. 相比run(),call()方法可以有返回值
  2. 方法可以抛出异常
  3. 支持泛型的返回值
  4. 借助FutureTask类，可以获取返回结果等。
/**
 * 创建多线程的方式三：实现Callable接口
 */
public class Thread03 {
    public static void main(String[] args) {
        MyThread03 m3 = new MyThread03();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(m3);
        FutureTask<Integer> f2 = new FutureTask<Integer>(m3);
        //创建线程
        Thread t1 = new Thread(futureTask);
        Thread t2 = new Thread(f2);
        t1.setName("线程一");
        t2.setName("线程二");
        //开启线程
        t1.start();
        t2.start();
        try {
            //获取返回值
            Integer sum = futureTask.get();
            System.out.println(t1.getName() + ":总和为" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
class MyThread03 implements Callable{
    private ReentrantLock lock = new ReentrantLock();
    private int number = 100;
    @Override
    public Object call() throws Exception {
        int sum = 0;
        while (true) {
            try {
                lock.lock();
                if (number > 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    sum += number;
                    if (Thread.currentThread().getName().equals("线程一"))
                        System.out.println("当前" + Thread.currentThread().getName() + "的总和为：" + sum);
                    number--;
                }else{
                    break;
                }
            } finally {
                lock.unlock();
            }
        }
        return sum;
    }
}
4、使用线程池
/**
 * 创建多线程的方式四：线程池
 */
public class Thread04 {
    public static void main(String[] args) {
        //创建线程池，设置最大线程数
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        //线程池的实现类，用于管理线程池的属性
        //ThreadPoolExecutor executorService1 = (ThreadPoolExecutor) executorService;

        //执行指定的线程操作，需要提供Runnable接口或Callable接口实现类的对象
        executorService.execute(new MyThread04_1());//适用于Runnable接口
        executorService.submit(new MyThread04_2());
        //关闭线程池
        executorService.shutdown();
    }

}
class MyThread04_1 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 MyThread04_2 implements Callable{
    @Override
    public Object call() throws Exception {
        for (int i = 0;i < 100;i++){
            if (i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
        return null;
    }
}

五、线程的通信

涉及的方法（java.long.Objeck中）：
wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
notify()：一旦执行此方法，就会唤醒wait的一个线程，如果有多个线程被wait，就唤醒优先级高的线程。
notifyAll()：一旦执行此方法，就会唤醒所有被wait的线程。

/**
 * 使线程交互性的输出1~100的数
 */
public class Communication {
    public static void main(String[] args) {
        Number n = new Number();
        Thread t1 = new Thread(n);
        Thread t2 = new Thread(n);

        t1.start();
        t2.start();
    }
}
class Number implements Runnable{
    private int number = 1;
    @Override
    public void run() {
        while (true){
            synchronized (this) {
                //解除被wait()阻塞的线程
                notify();
                if (number <= 100){
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;
                    try {
                        //使线程进入阻塞状态
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }
        }
    }
}

说明：wait()、notify()、notifyAll()三个方法必须使用在同步代码块或同步方法中；
   三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则会出现异常。

问题

sleep()和wait()的异同？
相同点：一旦执行方法，都可以使得线程进入阻塞状态
不同点：1）两个方法声明的位置不同：Thread类中声明的sleep()，Object类中声明的wait()
    2）调用的要求不同：sleep()可以在任何场景中调用。wait()必须使用在同步代码块或同步方法中
    3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放，wait()会释放。
一个木木的笨蛋
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中线程思维导图
05-31
Java中线程思维导图
Java多线程安全和死锁
qq_21543391的博客
08-13 130
线程生命周期 ➢新建:当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态 ➢就绪:处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它己具备了运行的条件，只是没分配到CPU资源 ➢运行:当就绪的线程被调度并获得CPU资源时,便进入运行状态，run()方法定义了线程的操作和功能 ➢阻塞:在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中，止自己的执行，进入阻塞状态 ➢死亡:线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束 线
多线程常用操作
weixin_45134615的博客
07-22 291
Day24 多线程 1. 多线程 1.7 常用方法 start():启动线程的唯一方式 setName():设置线程的名字 默认是Thread-0，Thread-1 getName():获取线程的名字 setPriority():设置线程优先级 getPriority():获取线程优先级 static currentThread():获取当前线程的内存地址 static sleep():睡眠当前线程，参数是睡眠的毫秒数 静态的，和用哪个对象没关系，写在哪个线程中，就获取哪个线程对象，就睡眠.
JavaSE多线程
matrix_studio的博客
12-10 380
1.基本概念：程序、进程、线程 程序(program)：为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程(process)：程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期 eg.：运行中的QQ，运行中的MP3播放器程序是静态的，进程是动态的进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多
Java自学习day19-使用同步方法解决实现Runnable接口的线程安全问题
加油鸭
05-15 154
使用同步方法解决实现Runnable接口的线程安全问题 * 关于同步方法的总结： * 1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。 * 2. 非静态的同步方法，同步监视器是：this * 静态的同步方法，同步监视器是：当前类本身 package com.atguigu.java; class Window3 implements Runnable { private int ticket = 100; @Override public
代码分析Java中线程的等待与唤醒
08-26
Java 中线程的等待与唤醒机制详解 Java 中的线程等待和唤醒机制是多线程编程中一个重要的概念，它们之间的相互作用能够实现线程之间的协作和同步。下面将深入剖析 Java 中线程的等待和唤醒机制的原理和实现。 等待...
剖析Java中线程编程的概念
09-03
Java线程模型是其多线程特性的基础，它提供了一种机制，使得程序可以在执行过程中并行地执行多个任务。Java运行时系统完全支持线程，并且所有类库都考虑到了多线程环境，这使得Java成为编写并发程序的理想选择。线程...
java中线程的状态学习笔记
08-26
Java中的线程状态学习笔记 Java中的线程状态是指线程在其生命周期中所经历的一系列状态。在Java开发中，了解线程的状态是非常重要的，因为它可以帮助我们更好地理解线程的行为和生命周期。下面我们将详细介绍Java中...
java 中线程等待与通知的实现
08-29
Java 中线程等待与通知的实现 Java 中线程等待与通知是 Java 并发编程中非常重要的概念。线程等待与通知机制允许线程之间相互通信，实现了多线程之间的协作和同步。下面详细介绍 Java 中线程等待与通知的实现。 一...
Lombok的hashCode方法
LiZhen314的博客
06-27 356
在继承关系中，父类的hashCode针对父类的所有属性进行运算，而子类的hashCode却只是针对子类才有的属性进行运算，立此贴提醒自己。callSuper = false，根据子类自身的字段值 来生成hashcode， 当两个子类对象比较时，只有子类对象的本身的字段值相同，父类字段值可以不同，callSuper = true，根据子类自身的字段值和从父类继承的字段值 来生成hashcode，当两个子。比较时，只有子类对象的本身的字段值和继承父类的字段值都相同，equals方法的返回值是true。
日常工作记录目录
与海
06-21 734
EasyExcel实现二维码下载与展示
Homebrew使用
gghh2015的博客
06-21 514
具体参考：https://blog.csdn.net/m0_67402970/article/details/126434901。简介：https://www.jianshu.com/p/f4c9cf0733ea。2、查看安装路径：brew list maven。官网：https://brew.sh/
Rust高性能日志库tklog0.0.8—支持mod设置参数
donnie4w技术专栏
06-21 956
tklog是rust高性能结构化日志库，支持同步日志，异步日志，支持自定义日志的输出格式，支持按时间，按文件大小分割日志文件，支持日志文件压缩备份，支持官方日志库标准API，支持mod独立参数设置
Android10 SystemUI系列 需求定制（二）隐藏状态栏通知图标，锁屏通知，可定制包名，渠道等
fighting_2017的博客
06-25 80
SystemUI 所包含的界面和模块比较多，这一节主要分享一下状态栏通知图标和通知栏的定制需求：隐藏状态栏通知图标，锁屏通知，可定制包名，渠道等来熟悉一下Systemui。
multiprocessing.Queue 多个进程生产和多个进程消费怎么处理
qh0526wy的博客
06-24 224
在主进程中，我们创建了多个消费者和生产者进程，并将它们启动。生产者进程将数据放入队列，消费者进程从队列中取出数据并处理。生产者进程完成后，我们向队列发送。进行多个生产者和多个消费者的场景时，队列可以很好地协调这些进程。这个模式允许多个生产者并发地向队列中放入数据，同时多个消费者并发地从队列中取出并处理数据，直到所有生产者完成生产，消费者接收到结束信号。函数，分别用于从队列中获取数据和向队列中放入数据。来确保队列可以在多个进程之间共享。方法等待队列中的所有任务完成时很有用。在这个示例中，我们创建了一个队列。
计算机等级考试-Java考试大纲
最新发布
weixin_54454406的博客
06-27 76
二级Java语言程序设计考试大纲。
JVM 相关知识整理
杨杨杨~~的博客
06-20 850
如果您觉得有用的话，记得给，写作不易啊^ _ ^。而且听说，实在白嫖的话，那欢迎常来啊!!!
SpringCloud微服务框架的原理及应用详解（一）
凛鼕将至的博客
06-21 1066
Spring Cloud是一个基于Spring Boot实现的服务治理工具包，在微服务架构中用于管理和协调服务。它提供了一系列框架和组件，如服务发现、配置管理、熔断器、智能路由等，用于简化分布式系统的开发。Spring Cloud通过提供一系列开箱即用的组件和工具，帮助开发者快速构建和部署微服务架构的系统。
mapstruct实现各个实体间的类型转换（DTO转BO、BO转Entity）的实践
m0_73376570的博客
06-26 1003
***/@Data@Data@Mapper//将DTO转换为BO//将List<BO>转换为List<DTO>//将BO转换为DTO。
java中 线程的生命周期
05-11
Java中线程的生命周期可分为五个状态：新建状态、就绪状态、运行状态、阻塞状态和终止状态。 1. 新建状态：新建线程对象后，线程处于新建状态，此时系统给线程分配内存空间，但尚未开始执行线程的run()方法。 2. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值