AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

多线程与并发编程【守护线程、线程同步】(三)-全面详解（学习总结---从入门到深化）

2024-01-15 183
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 多线程与并发编程【守护线程、线程同步】(三)-全面详解（学习总结---从入门到深化）

守护线程


什么是守护线程

 在Java中有两类线程：


       User Thread(用户线程)：就是应用程序里的自定义线程。

       Daemon Thread(守护线程)：比如垃圾回收线程，就是最典型的守护线程。


守护线程（即Daemon Thread），是一个服务线程，准确地来说 就是服务其他的线程，这是它的作用，而其他的线程只有一种，那 就是用户线程。


守护线程特点：


     守护线程会随着用户线程死亡而死亡。


守护线程与用户线程的区别：


用户线程，不随着主线程的死亡而死亡。用户线程只有两种情况会 死掉，1在run中异常终止。2正常把run执行完毕，线程死亡。

守护线程，随着用户线程的死亡而死亡，当用户线程死亡守护线程 也会随之死亡。


守护线程的使用

/**
* 守护线程类
*/
class Daemon implements  Runnable{
    @Override
    public void run() {
        for(int i=0;i<20;i++){
              System.out.println(Thread.currentThread().getName()+" "+i);
            try {
                Thread.sleep(2000);
           } catch (InterruptedException e){
                e.printStackTrace();
           }
       }
   }
}
class UsersThread implements Runnable{
    @Override
    public void run() {
        Thread t = new Thread(new Daemon(),"Daemon");
        //将该线程设置为守护线程
        t.setDaemon(true);
        t.start();
        for(int i=0;i<5;i++){
          System.out.println(Thread.currentThread().getName()+" "+i);
            try {
                Thread.sleep(500);
           } catch (InterruptedException e){
                e.printStackTrace();
           }
       }
   }
}
public class DaemonThread {
    public static void main(String[] args)throws Exception {
        Thread t = new Thread(new UsersThread(),"UsersThread");
        t.start();
        Thread.sleep(1000);
        System.out.println("主线程结束");
   }
}


线程同步

什么是线程同步


线程冲突现象


同步问题的提出


现实生活中，我们会遇到“同一个资源，多个人都想使用”的问题。 比如：教室里，只有一台电脑，多个人都想使用。天然的解决办法 就是，在电脑旁边，大家排队。前一人使用完后，后一人再使用。


线程同步的概念


处理多线程问题时，多个线程访问同一个对象，并且某些线程还想 修改这个对象。 这时候，我们就需要用到“线程同步”。 线程同步其 实就是一种等待机制，多个需要同时访问此对象的线程进入这个对 象的等待池形成队列，等待前面的线程使用完毕后，下一个线程再 使用。


线程冲突案例演示


我们以银行取款经典案例来演示线程冲突现象。 银行取钱的基本流程基本上可以分为如下几个步骤。


（1）用户输入账户、密码，系统判断用户的账户、密码是否匹配。

（2）用户输入取款金额

（3）系统判断账户余额是否大于或等于取款金额

（4）如果余额大于或等于取款金额，则取钱成功；如果余额小于取 款金额，则取钱失败。

/**
* 账户类
*/
class Account{
    //账号
    private String accountNo;
    //账户的余额
    private double balance;
    public Account() {
   }
    public Account(String accountNo, double balance) {
        this.accountNo = accountNo;
        this.balance = balance;
   }
    public String getAccountNo() { return accountNo;
   }
    public void setAccountNo(String accountNo) {
        this.accountNo = accountNo;
   }
    public double getBalance() {
        return balance;
   }
    public void setBalance(double balance) {
        this.balance = balance;
   }
}
/**
* 取款线程
*/
class DrawThread implements Runnable{
    //账户对象
    private Account account;
    //取款金额
    private double drawMoney;
    public DrawThread(Account account,double drawMoney){
        this.account = account;
        this.drawMoney = drawMoney;
   }
    /**
     * 取款线程
 */
    @Override
    public void run() {
        //判断当前账户余额是否大于或等于取款金额
        if(this.account.getBalance() >= this.drawMoney){
          System.out.println(Thread.currentThread().getName()+" 取钱成功！吐出钞
票："+this.drawMoney);
            try {
                Thread.sleep(1000);
           } catch (InterruptedException e){
                e.printStackTrace();
           }
            //更新账户余额
          this.account.setBalance(this.account.getBalance()- this.drawMoney);
            System.out.println("\t 余额为："+this.account.getBalance());
       }else{
          System.out.println(Thread.currentThread().getName()+" 取钱失败，余额不足");
       }
   }
}
public class TestDrawMoneyThread {
    public static void main(String[] args) {
        Account account = new Account("1234",1000);
        new Thread(new DrawThread(account,800),"老公").start();
        new Thread(new DrawThread(account,800),"老婆").start();
   }
}


实现线程同步

由于同一进程的多个线程共享同一块存储空间，在带来方便的同 时，也带来了访问冲突的问题。Java语言提供了专门机制以解决这 种冲突，有效避免了同一个数据对象被多个线程同时访问造成的这 种问题。这套机制就是synchronized关键字。


synchronized语法结构：


synchronized(锁对象){ 
　　 同步代码
 }


synchronized关键字使用时需要考虑的问题：


  需要对那部分的代码在执行时具有线程互斥的能力(线程互斥：并行变串行)。

  需要对哪些线程中的代码具有互斥能力(通过synchronized锁对象来决定)。


它包括两种用法：


synchronized 方法和 synchronized 块。


1 synchronized 方法


通过在方法声明中加入 synchronized关键字来声明，语法如 下：

public  synchronized  void accessVal(int newVal);


synchronized 在方法声明时使用：放在访问控制符(public)之前 或之后。这时同一个对象下synchronized方法在多线程中执行 时，该方法是同步的，即一次只能有一个线程进入该方法，其他 线程要想在此时调用该方法，只能排队等候，当前线程(就是在 synchronized方法内部的线程)执行完该方法后，别的线程才能 进入。


2 synchronized块


synchronized 方法的缺陷：若将一个大的方法声明为 synchronized 将会大大影响效率。 Java 为我们提供了更好的解决办法，那就是 synchronized 块。 块可以让我们精确地控制到具体的“成员变量”，缩小同步的范 围，提高效率。


修改线程冲突案例演示

/**
* 账户类
*/
class Account{
    //账号
    private String accountNO;
    //账户余额
    private double balance;
    public Account() {
   }
    public Account(String accountNO, double balance) {
        this.accountNO = accountNO;
        this.balance = balance;
   }
    public String getAccountNO() {
        return accountNO;
   }
    public void setAccountNO(String accountNO) {
        this.accountNO = accountNO;
}
    public double getBalance() {
        return balance;
   }
    public void setBalance(double balance) {
        this.balance = balance;
   }
}
/**
* 取款线程
*/
class DrawThread implements Runnable{
    //账户对象
    private Account account;
    //取款金额
    private double drawMoney;
    public DrawThread(){
   }
    public DrawThread(Account account,double drawMoney){
        this.account = account;
        this.drawMoney = drawMoney;
   }
    /**
     * 取款线程体
     */
    @Override
 public void run() {
        synchronized (this.account){
            //判断当前账户余额是否大于或等于取款金额
            if(this.account.getBalance() >= this.drawMoney){
              System.out.println(Thread.currentThread().getName()+" 取钱成功！突出钞票"+this.drawMoney);
                try {
                    Thread.sleep(1000);
               } catch(InterruptedException e) {
                    e.printStackTrace();
               }
                //更新账户余额
              this.account.setBalance(this.account.getBalance() - this.drawMoney);
                System.out.println("\t 余额为："+this.account.getBalance());
           }else{
              System.out.println(Thread.currentThread().getName()+" 取钱失败，余额不足");
           }
       }
   }
}
public class TestDrawMoneyThread {
    public static void main(String[] args) {
        Account account = new Account("1234",1000);
        new Thread(new DrawThread(account,800),"老公").start();
        new Thread(new DrawThread(account,800),"老婆").start();
   }
}


线程同步的使用

使用this作为线程对象锁


语法结构：

synchronized(this){
　　    //同步代码
 }


或

public  synchronized  void accessVal(int newVal){
    //同步代码
}


/**
* 定义程序员类
*/
class Programmer{
    private String name;
    public Programmer(String name){
        this.name = name;
   }
    /**
     * 打开电脑
     */
    synchronized  public  void computer(){
            try {
                System.out.println(this.name + " 接通电源");
                Thread.sleep(500);
                System.out.println(this.name + " 按开机按键");
                Thread.sleep(500);
                System.out.println(this.name + " 系统启动中");
                Thread.sleep(500);
                System.out.println(this.name + " 系统启动成功");
           } catch (InterruptedException e){
                e.printStackTrace();
           }
   }
    /**
     * 编码
     */
    synchronized public void coding(){
            try {
                System.out.println(this.name + " 双击Idea");
                Thread.sleep(500);
                System.out.println(this.name + " Idea启动完毕");
                Thread.sleep(500);
                System.out.println(this.name + " 开开心心的写代码");
           } catch (InterruptedException e){
                e.printStackTrace();
           }
       }
}
/**
* 打开电脑的工作线程
*/
class Working1 extends Thread{
    private  Programmer p;
    public Working1(Programmer p){
        this.p = p;
   }
    @Override
    public void run() {
        this.p.computer();
   }
}
/**
* 编写代码的工作线程
*/
class Working2 extends Thread{
    private  Programmer p;
    public Working2(Programmer p){
        this.p = p;
   }
    @Override
    public void run() {
        this.p.coding();
   }
}
public class TestSyncThread {
    public static void main(String[] args) {
        Programmer p = new Programmer("张三");
        new Working1(p).start();
        new Working2(p).start();
   }
}


使用字符串作为线程对象锁


语法结构：

synchronized(“字符串”){
　　    //同步代码
 }


/**
* 定义程序员类
*/
class Programmer{
    private String name;
    public Programmer(String name){
        this.name = name;
   }
    /**
     * 打开电脑
  */
    synchronized  public  void computer(){
            try {
              System.out.println(this.name + " 接通电源");
                Thread.sleep(500);
              System.out.println(this.name + " 按开机按键");
                Thread.sleep(500);
              System.out.println(this.name + " 系统启动中");
                Thread.sleep(500);
              System.out.println(this.name + " 系统启动成功");
           } catch (InterruptedExceptione) {
                e.printStackTrace();
           }
   }
    /**
     * 编码
     */
    synchronized public void coding(){
            try {
              System.out.println(this.name + " 双击Idea");
                Thread.sleep(500);System.out.println(this.name + " Idea启动完毕");
                Thread.sleep(500);
              System.out.println(this.name + " 开开心心的写代码");
           } catch (InterruptedExceptione) {
                e.printStackTrace();
           }
       }
    /**
     * 去卫生间
     */
    public void wc(){
        synchronized ("suibian") {
            try {
              System.out.println(this.name + " 打开卫生间门");
                Thread.sleep(500);
              System.out.println(this.name + " 开始排泄");
                Thread.sleep(500);
              System.out.println(this.name + " 冲水");
                Thread.sleep(500);
              System.out.println(this.name + " 离开卫生间");
 } catch (InterruptedExceptione) {
                e.printStackTrace();
           }
       }
   }
}
/**
* 打开电脑的工作线程
*/
class Working1 extends Thread{
    private  Programmer p;
    public Working1(Programmer p){
        this.p = p;
   }
    @Override
    public void run() {
        this.p.computer();
   }
}
/**
* 编写代码的工作线程
*/
class Working2 extends Thread{
    private  Programmer p;
    public Working2(Programmer p){
        this.p = p;
   }
    @Override
    public void run() {
  this.p.coding();
   }
}
/**
* 去卫生间的线程
*/
class WC extends Thread{
    private  Programmer p;
    public WC(Programmer p){
        this.p = p;
   }
    @Override
    public void run() {
        this.p.wc();
   }
}
public class TestSyncThread {
    public static void main(String[] args)
{
        Programmer p = new Programmer("张三");
        Programmer p1 = new Programmer("李四");
        Programmer p2 = new Programmer("王五");
        new WC(p).start();
        new WC(p1).start();
        new WC(p2).start();
   }
}


文章标签：
Java
数据安全/隐私保护
块存储
关键词：
多线程线程
并发编程线程
线程入门
线程学习
线程守护
童小纯
目录
相关文章
智物科技库
|
3月前
|
人工智能 安全 调度
Python并发编程之线程同步详解
并发编程在Python中至关重要，线程同步确保多线程程序正确运行。本文详解线程同步机制，包括互斥锁、信号量、事件、条件变量和队列，探讨全局解释器锁（GIL）的影响及解决线程同步问题的最佳实践，如避免全局变量、使用线程安全数据结构、精细化锁的使用等。通过示例代码帮助开发者理解并提升多线程程序的性能与可靠性。
智物科技库
114 0
AI小云
|
3月前
|
安全 算法 Java
Java 多线程：线程安全与同步控制的深度解析
本文介绍了 Java 多线程开发的关键技术，涵盖线程的创建与启动、线程安全问题及其解决方案，包括 synchronized 关键字、原子类和线程间通信机制。通过示例代码讲解了多线程编程中的常见问题与优化方法，帮助开发者提升程序性能与稳定性。
AI小云
139 0
IT小码
|
5月前
|
Java 开发者 Kotlin
华为仓颉语言初识：并发编程之线程的基本使用
本文详细介绍了仓颉语言中线程的基本使用，包括线程创建（通过`spawn`关键字）、线程名称设置、线程执行控制（使用`get`方法阻塞主线程以获取子线程结果）以及线程取消（通过`cancel()`方法）。文章还指出仓颉线程与Java等语言的差异，例如默认不提供线程名称。掌握这些内容有助于开发者高效处理并发任务，提升程序性能。
IT小码
171 2
兵临天下19970108016
|
3月前
|
数据采集 监控 调度
干货分享“用 多线程 爬取数据”：单线程 + 协程的效率反超 3 倍，这才是 Python 异步的正确打开方式
在 Python 爬虫中，多线程因 GIL 和切换开销效率低下，而协程通过用户态调度实现高并发，大幅提升爬取效率。本文详解协程原理、实战对比多线程性能，并提供最佳实践，助你掌握异步爬虫核心技术。
兵临天下19970108016
271 0
啦啦啦191
|
4月前
|
Java 数据挖掘 调度
Java 多线程创建零基础入门新手指南：从零开始全面学习多线程创建方法
本文从零基础角度出发，深入浅出地讲解Java多线程的创建方式。内容涵盖继承`Thread`类、实现`Runnable`接口、使用`Callable`和`Future`接口以及线程池的创建与管理等核心知识点。通过代码示例与应用场景分析，帮助读者理解每种方式的特点及适用场景，理论结合实践，轻松掌握Java多线程编程 essentials。
啦啦啦191
242 5
蓝易云
|
8月前
|
Python
python3多线程中使用线程睡眠
本文详细介绍了Python3多线程编程中使用线程睡眠的基本方法和应用场景。通过 `time.sleep()`函数，可以使线程暂停执行一段指定的时间，从而控制线程的执行节奏。通过实际示例演示了如何在多线程中使用线程睡眠来实现计数器和下载器功能。希望本文能帮助您更好地理解和应用Python多线程编程，提高程序的并发能力和执行效率。
蓝易云
250 20
摘星.
|
5月前
|
机器学习/深度学习 消息中间件 存储
【高薪程序员必看】万字长文拆解Java并发编程！(9-2)：并发工具-线程池
🌟 ​大家好，我是摘星！​ 🌟今天为大家带来的是并发编程中的强力并发工具-线程池，废话不多说让我们直接开始。
摘星.
188 0
蓝易云
|
8月前
|
Linux
Linux编程： 在业务线程中注册和处理Linux信号
通过本文，您可以了解如何在业务线程中注册和处理Linux信号。正确处理信号可以提高程序的健壮性和稳定性。希望这些内容能帮助您更好地理解和应用Linux信号处理机制。
蓝易云
132 26
蓝易云
|
8月前
|
Linux
Linux编程： 在业务线程中注册和处理Linux信号
本文详细介绍了如何在Linux中通过在业务线程中注册和处理信号。我们讨论了信号的基本概念，并通过完整的代码示例展示了在业务线程中注册和处理信号的方法。通过正确地使用信号处理机制，可以提高程序的健壮性和响应能力。希望本文能帮助您更好地理解和应用Linux信号处理，提高开发效率和代码质量。
蓝易云
136 17
栈江湖
|
10月前
|
存储 安全 Java
Java多线程编程秘籍：各种方案一网打尽，不要错过！
Java 中实现多线程的方式主要有四种：继承 Thread 类、实现 Runnable 接口、实现 Callable 接口和使用线程池。每种方式各有优缺点，适用于不同的场景。继承 Thread 类最简单，实现 Runnable 接口更灵活，Callable 接口支持返回结果，线程池则便于管理和复用线程。实际应用中可根据需求选择合适的方式。此外，还介绍了多线程相关的常见面试问题及答案，涵盖线程概念、线程安全、线程池等知识点。
栈江湖
597 2