多线程（三）

最新推荐文章于 2024-08-07 11:15:21 发布
最新推荐文章于 2024-08-07 11:15:21 发布
阅读量71 收藏
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/catcat2003/article/details/124131760
版权

线程的死锁问题

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。
解决方法
1.专门的算法、原则
2.尽量减少同步资源的定义
3.尽量避免嵌套同步

例

public class ThreadTest {

	public static void main(String[] args) {
		StringBuffer s1=new StringBuffer();
		StringBuffer s2=new StringBuffer();
		
		new Thread() {
			public void run() {
				synchronized(s1) {
					s1.append("a");
					s2.append("1");
					
					try {
						Thread.sleep(100);
					}catch(InterruptedException e) {
						e.printStackTrace();
					}
					
					synchronized(s2) {
						s1.append("b");
						s2.append("2");
						
						System.out.println(s1);
						System.out.println(s2);
					}
				}
			}
		}.start();
		
		new Thread(new Runnable() {
			public void run() {
				synchronized(s2) {
					s1.append("c");
					s2.append("3");
					
					try {
						Thread.sleep(100);
					}catch(InterruptedException e) {
						e.printStackTrace();
					}
					
					synchronized(s1) {
						s1.append("d");
						s2.append("4");
						
						System.out.println(s1);
						System.out.println(s2);
					}
				}
			}
		}).start();
	}

}

在两段同步代码中加入Thread.sleep(100);导致第一个线程拿到锁s1时停留短暂的时间，在这短时间内第二个线程那到了锁s2，接下来第一个线程需要锁s2才能执行下去，而第二个线程则需要锁s1才能执行下去，导致两个线程僵持不下，形成死锁局面。
当不加入Thread.sleep(100)时，程序也有概率会出现死锁局面，只是加入后使得出现死锁的概率大大增加了。

Lock锁解决线程同步安全问题

在这里插入图片描述
Lock实际是一个接口。

import java.util.concurrent.locks.ReentrantLock;

class Window implements Runnable{
    private int ticket=100;

    //1.实例化ReentrantLock
    private ReentrantLock lock=new ReentrantLock(true);
    //true表示公平的意思，就是假如三条线程先后进来，则按顺序进入同步资源
    //先进先出原则，若括号内不写true，则默认是false

    public void run() {
        while(true) {
            try{
                //2.调用lock方法
                lock.lock();
                if(ticket>0) {

                    try {
                        Thread.sleep(100);
                    }catch(InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName()+":"+ticket);
                    ticket--;
                }else {
                    break;
                }
            }finally {
                lock.unlock();//3.调用解锁方法
            }
        }
    }
}


public class ThreadTest {
    public static void main(String[] args) {
        Window w=new Window();
        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        t1.setName("线程一");
        t2.setName("线程二");
        t1.start();
        t2.start();
    }
}

面试题：synchronized与lock的异同？
同：二者都可以解决线程的安全问题
不同：synchronize机制在执行完相应的同步代码后，自动释放同步监视器。
Lock需要手动启动同步（lock（）），同时结束同步也需要手动实现（unlock（））。
在这里插入图片描述
其实用哪种方法解决线程安全都行都行。
面试题：如何解决线程安全问题？有几种方式？
三种：synchronize两种（同步代码块、同步方法），还有一种Lock。

例：

import java.util.concurrent.locks.ReentrantLock;

/*
解决银行存钱两个人同时操作一个账户线程安全问题
分析：
是否是多线程？
是否有共享数据？
是否有线程安全问题？
需要考虑如何解决线程安全问题？同步机制：三种方法
 */
class Account{
    private double balance;
    public Account(double balance){
        this.balance=balance;
    }

    private ReentrantLock lock=new ReentrantLock(true);

    //存钱
    public void deposit(double amt){
        try{
            lock.lock();
            if(amt>0){
                balance+=amt;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"存钱成功，余额为："+balance);
            }
        }finally {
            lock.unlock();
        }

    }
}

class Customer extends Thread{
    private Account acct;
    public Customer(Account acct){
        this.acct=acct;
    }

    @Override
    public void run() {
        for(int i=0;i<3;i++){
            acct.deposit(1000);
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        Account acct=new Account(0);
        Customer c1=new Customer(acct);
        Customer c2=new Customer(acct);
        c1.setName("甲");
        c2.setName("乙");
        c1.start();
        c2.start();
    }
}

注意，多线程的lock锁也必须是同一个锁，具体情况具体分析需不需要加上static。

线程通信的例题

在这里插入图片描述
前提：wait（）方法导致线程进入阻塞状态的同时会释放同步锁。
notify()：唤醒一个线程，若有多个线程处于wait（阻塞）状态，则先唤醒优先级更高的线程，同级别则随机唤醒。
notifyAll（）：唤醒所有wait（阻塞）状态的线程。
sleep（）导致先暂停一会儿，但不会释放同步锁。
wait，notify，notifyAll方法都必须使用在同步方法块或同步方法中，且这些方法的调用者都是当前的同步监视器。

class Number implements Runnable{
    private int number=1;

    @Override
    public void run() {
        while (true){
            synchronized (this){
                notify();
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(number<=100){
                    System.out.println(Thread.currentThread().getName()+":"+number);
                    number++;
                }else {
                    break;
                }
                try {
                    wait();
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        Number n = new Number();
        Thread h1=new Thread(n);
        Thread h2=new Thread(n);
        h1.setName("线程一");
        h2.setName("线程二");
        h1.start();
        h2.start();

    }
}

面试题：
sleep（）和wait（）方法的异同：
相同：一旦执行方法，都可以使得当前的线程进入阻塞状态。
不同：
1.两个方法声明的位置不同：Thread类中声明sleep（），Object类中声明wait（）
2.调用的要求不同：sleep（）可以在任何需要的场景下调用。wait（）必须使用在同步代码块中调用。
3.关于是否释放同步监视器，如果两个方法都使用在同步代码块或同步方法中，sleep不会释放锁，但是wait会释放。

例：
实现柜台进货售货

//柜员
class Clerck{
    private int num=0;
    public synchronized void produce(){
        if(num<20){
            num++;
            System.out.println(Thread.currentThread().getName()+"开始生产第："+num+"个产品");
            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public synchronized void buy(){
        if(num>0){
            System.out.println(Thread.currentThread().getName()+"开始购买第："+num+"个产品");
            num--;
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//生产者
class Producer extends Thread{
    private Clerck c;

    public Producer(Clerck c){
        this.c=c;
    }

    @Override
    public void run() {
        while (true){
            try{
                Thread.sleep(10);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            c.produce();
        }
    }
}

//消费者
class Consummer extends Thread{
    private Clerck c;

    public Consummer(Clerck c){
        this.c=c;
    }

    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(100);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            c.buy();
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        Clerck c=new Clerck();
        Consummer h=new Consummer(c);
        Producer p=new Producer(c);
        h.setName("消费线");
        p.setName("生产线");
        h.start();
        p.start();
    }
}

JDK 5.0新增线程创建方式

新增方式一：实现Callable接口
与使用Runnable相比，Callable功能更强大些。
1.相比run（）方法，可以有返回值
2.方法可以抛出异常
3.支持泛型的返回值
4.需借助Future Task类，比如获取返回结果

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/*
打印出1-10的数，并且求和输出
 */
//1.创建一个实现Callable的实现类
class numThread implements Callable {
    private int num=0;
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        for(int i=0;i<10;i++){
            System.out.println(i);
            num+=i;
        }
        return num;
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        numThread numThread = new numThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTack构造器中
        //创建FutureTask的对象
        FutureTask futureTask=new FutureTask(numThread);
        //将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象并调用start
        new Thread(futureTask).start();

        try {
            //6.获取Callable中的call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
            Object num=futureTask.get();
            System.out.println("总和为："+num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
1.call（）可以有返回值。
2.call（）可以抛出异常，被外面的操作捕获，获取异常信息。
3.Callable是支持泛型的。

新增方式二：使用线程池

在这里插入图片描述

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

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

public class ThreadTest {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service= Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1=(ThreadPoolExecutor) service;
        //设置线程池的属性
        //System.out.println(service.getClass());
        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();

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

面试题：创建多线程有四种方式。

啥好吃的啊给我来一口
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring事务死锁
cap423654的博客
09-07 1517
### Error updating database. Cause: com.mysql.jdbc.exceptions.jdbc4.MySQLTransactionRollbackException: Lock wait timeout exceeded; try restarting transaction ### The error may involve com.example...
2.3 并发程序中的死锁
CSDN_dzh的博客
03-16 223
文章目录死锁的概念死锁的四个必要条件死锁实例std::lock避免死锁的建议 死锁的概念 死锁是指多个进程因竞争资源而造成的一种僵局（互相等待），若无外力作用，这些进程都将无法向前推进。 通常，死锁是由下面的原因产生的： 争夺系统资源 请求和释放资源的顺序不当 死锁的四个必要条件 1）互斥条件 一个资源每次只能被一个进程使用，即在一段时间内某资源仅为一个进程所占有。此时若有其他进程请...
java死锁的原理和排除_Java中死锁的原理实战分析|chu
weixin_31182871的博客
02-24 96
本文实例讲述了Java中死锁的原理。分享给大家供大家参考，具体如下：一 点睛当两个线程相互等待对方释放同步监视器时就会发生死锁，Java虚拟机没有监测、也没有采用措施来处理死锁情况，所以多线程编程时应该采取措施避免死锁的出现。一旦出现死锁，整个程序既不会发生任何异常，也不会给出任何提示，只是所有线程处于阻塞状态，无法继续。二 代码class A { public synchronized...
java读写锁升级与降级、并会发现死锁。抛出异常
绚烂的天空
08-10 970
package com.huawei.test; import java.util.HashMap; import java.util.Map; public class SpinReadWriteLock { private volatile Thread writeThread = null; private volatile int writeCount = 0; ...
mysql死锁抛出异常_如何排查和处理 MySQL 死锁异常？详细分析及解决方法步骤
weixin_29017445的博客
02-02 1037
MySQL 死锁异常是我们经常会遇到的线上异常类别，一旦线上业务日间复杂，各种业务操作之间往往会产生锁冲突，有些会导致死锁异常。这种死锁异常一般要在特定时间特定数据和特定业务操作才会复现，并且分析解决时还需要了解 MySQL 锁冲突相关知识，所以一般遇到这些偶尔出现的死锁异常，往往一时没有头绪，不好处理。本篇文章会讲解一下如果线上发生了死锁异常，如何去排查和处理。除了系列前文讲解的有关加锁和锁冲突...
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
C#高级--多线程详解
李宥的博客
10-03 4万+
C#高级–多线程详解 零、文章目录 一、什么是多线程 1、进程 当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。 而一个进程又是由多个线程所组成的。 2、线程 线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。 3、句柄 句柄是Windows系统中对象或实例的标识，这些对象包括模块、应用程序实例、窗口、控制、位图、GDI对象、资源、文件等。 4、多线程 （1）多线程概念 多线程是指程序中
java 多线程-01-继承Thread类实现多线程 三种写法
yangchao1234_的博客
06-10 1万+
继承Thread类实现多线程 三种写法 public class Thread_01_demo { public static void main(String[] args) { Thread t1 =new Thread(()->{ System.out.println("hello,I am "+Thread.currentThread().getName()); },"a"); t1.start();
SpringBoot--多线程处理
IT利刃出鞘的博客
07-31 1万+
本文介绍SpringBoot多线程处理的方案。
Java多线程三种主要实现方式解析
08-18
Java多线程三种主要实现方式解析 Java多线程三种主要实现方式解析是Java编程语言中最重要的概念之一。在 Java 中，实现多线程有多种方式，本文将详细介绍 Java 中的三种主要实现方式：继承Thread类、实现Runnable...
MFC MultiThread（多线程三个实例）.zip
03-17
MFC MultiThread（多线程三个实例）This file contains a summary of what you will find in each of the files that make up your MultiThread11 application.
实时多线程三维引擎内核的研究与实现
03-17
论文利用多核处理器所带来的硬件性能和面向对象技术所带来的开发效率的提升,将并行并发同面向对象技术融合,实现了面向对象的多线程并行实时三维引擎。新的实时三维引擎既具有面向对象特征,又使程序并行运行变得容易...
c语言多进程多线程编程
07-21
在计算机科学中，多进程和多线程是两种并发执行的方式，它们允许程序在同一时间处理多个任务，从而提高系统的效率和响应性。C语言作为一门底层且强大的编程语言，提供了丰富的系统调用接口来实现多进程和多线程编程...
多线程 hbase
03-03
三、示例：多线程HBase写入 创建一个线程池，每个任务负责写入一批记录到HBase。每个任务先构建`Put`对象，然后在主线程中提交到`HTable`，以批量写入的方式提高效率。同时，确保每个线程在执行写入前获取`HTable`的...
【Spring Boot】高效配置管理: 易用性与灵活性并重
weixin_68020300的博客
08-07 1251
本文探讨了Spring Boot中多样化的配置读取方法及其应用场景，强调了配置管理的重要性，并展示了Spring Boot如何通过灵活多变的配置选项简化这一过程。此外，文章还展望了配置管理领域未来的技术趋势和发展方向。对于任何希望深入了解Spring Boot配置管理的开发者来说，这是一篇不容错过的好文。
C++ - 函数重载
jiaowenjie的专栏
08-06 328
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 220
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
Spring事务
最新发布
c1tenj2的博客
08-07 436
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值