【java学习—十五】线程的同步与死锁（5）

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量64 收藏
点赞数
分类专栏： java学习 文章标签： java 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44883789/article/details/134443688
版权

文章目录

1. 多线程产生的问题

问题：
同一个账户，支付宝转账，微信转账。两个手机，一个手机开支付宝，另一个手机开微信。假设账户上有3000元，支付宝和微信同时提款2000，这时你的账户余额会变成了-1000元吗？
答：
当然不会，出现就有问题了
    
多个线程执行的不确定性引起执行结果的不稳定
多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

代码实现：

package day15;

public class Test2 {
	public static void main(String[] args) {
		
		//定义账户对象
		Account a = new Account();
		
		//多线程对象
		User u_weixin = new User(a, 2000);
		User u_zhifubao = new User(a, 2000);
		
		Thread weixin = new Thread(u_weixin, "微信");
		Thread zhifubao = new Thread(u_zhifubao, "支付宝");
		
		weixin.start();
		zhifubao.start();
		
	}

}

class Account{
	public static int money = 3000;//全局变量，所有操作共享这个变量
	
	/**
	 * 提款先判断账户钱够不够
	 * 多线程调用这个方法就有问题，线程共享资源时，一个线程在执行这个方法没有完毕时，另一个线程又开始执行这个方法
	 * 解决思路：先让一个线程整体执行完这个方法，另一个线程再执行。
	 * @param m
	 */
	public void drawing(int m) {
		String name = Thread.currentThread().getName();
		
		if(money < m) {
			System.out.println(name + "操作，账户金额不足：" + money);
		}else {
			System.out.println(name + "操作，账户原有金额：" + money);
			System.out.println(name + "操作，取款金额：" + m);
			
			money = money - m;
			
			System.out.println(name + "操作，取款后的余额：" + money);
		}
		
	}
}

class User implements Runnable{
	
	Account account;
	int money;
	
	public User(Account account, int money) {
		this.account = account;
		this.money = money;
	}
	
	@Override
	public void run() {
		account.drawing(money);
		
	}
}

运行结果：

在这里插入图片描述

发现金额变成 -1000 了

    

多线程出现了安全问题

问题的原因：
    当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

解决办法 :
    对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

2. Synchronized 的使用方法

Java 对于多线程的安全问题提供了专业的解决方式：

同步机制

1 、 synchronized 还可以放在方法声明中，表示整个方法为同步方法。
如果针对对象要加同步锁，那就加在方法上，例如：
    public synchronized void show (String name){
        ....
    }

2 、 锁 代码块

如果针对某一段代码需要加同步锁，那就直接在代码块上加同步锁，例如：
    synchronized ( 对象） {
        // 需要被同步的代码;
    }

解决方法：
直接在方法上加上synchronized关键字

package day15;

public class Test2 {
	public static void main(String[] args) {
		
		//定义账户对象
		Account a = new Account();
		
		//多线程对象
		User u_weixin = new User(a, 2000);
		User u_zhifubao = new User(a, 2000);
		
		Thread weixin = new Thread(u_weixin, "微信");
		Thread zhifubao = new Thread(u_zhifubao, "支付宝");
		
		weixin.start();
		zhifubao.start();
		
	}
}

class Account{
	public static int money = 3000;//全局变量，所有操作共享这个变量
	
	/**
	 * 提款先判断账户钱够不够
	 * 多线程调用这个方法就有问题，线程共享资源时，一个线程在执行这个方法没有完毕时，另一个线程又开始执行这个方法
	 * 解决思路：先让一个线程整体执行完这个方法，另一个线程再执行。
	 * 通过 synchronized同步锁 来完成
	 * 可以直接在方法上加上synchronized关键字
	 * 在普通方法上加同步锁synchronized，锁的是整个对象，不是某一个方法
	 * @param m
	 */
	public synchronized void drawing(int m) {
		String name = Thread.currentThread().getName();
		
		if(money < m) {
			System.out.println(name + "操作，账户金额不足：" + money);
		}else {
			System.out.println(name + "操作，账户原有金额：" + money);
			System.out.println(name + "操作，取款金额：" + m);
			
			money = money - m;
			
			System.out.println(name + "操作，取款后的余额：" + money);
		}
	}
		
}

class User implements Runnable{
	
	Account account;
	int money;
	
	public User(Account account, int money) {
		this.account = account;
		this.money = money;
	}
	
	@Override
	public void run() {
		account.drawing(money);
		
	}
}

运行结果：

在这里插入图片描述

在普通方法上加同步锁synchronized，锁的是整个对象，不是某一个方法

举例：

package day15;

public class Test2 {
	public static void main(String[] args) {
		
		//定义账户对象
		Account a = new Account();
		
		//多线程对象
		User u_weixin = new User(a, 2000);
		User u_zhifubao = new User(a, 2000);
		
		Thread weixin = new Thread(u_weixin, "微信");
		Thread zhifubao = new Thread(u_zhifubao, "支付宝");
		
		weixin.start();
		zhifubao.start();
		
		
	}

}

class Account{
	public static int money = 3000;//全局变量，所有操作共享这个变量
	
	/**
	 * 提款先判断账户钱够不够
	 * 多线程调用这个方法就有问题，线程共享资源时，一个线程在执行这个方法没有完毕时，另一个线程又开始执行这个方法
	 * 解决思路：先让一个线程整体执行完这个方法，另一个线程再执行。
	 * 通过 synchronized同步锁 来完成
	 * 可以直接在方法上加上synchronized关键字
	 * 在普通方法上加同步锁synchronized，锁的是整个对象，不是某一个方法
	 * 
	 * 普通方法加同步锁，锁的是当前方法对应的对象，当前的对象的所有加了同步锁的方法是共用一个同步锁
	 * @param m
	 */
	public synchronized void drawing(int m) {
		String name = Thread.currentThread().getName();
		
		if(money < m) {
			System.out.println(name + "操作，账户金额不足：" + money);
		}else {
			System.out.println(name + "操作，账户原有金额：" + money);
			System.out.println(name + "操作，取款金额：" + m);
			
			money = money - m;
			
			System.out.println(name + "操作，取款后的余额：" + money);
		}
		
	}
	
	public synchronized void drawing1(int m) {
		String name = Thread.currentThread().getName();
		
		if(money < m) {
			System.out.println(name + "操作，账户金额不足：" + money);
		}else {
			System.out.println(name + "操作，账户原有金额：" + money);
			System.out.println(name + "操作，取款金额：" + m);
			
			money = money - m;
			
			System.out.println(name + "操作，取款后的余额：" + money);
		}
		
	}
	
	
}

class User implements Runnable{
	
	Account account;
	int money;
	
	public User(Account account, int money) {
		this.account = account;
		this.money = money;
	}
	
	@Override
	public void run() {

		if(Thread.currentThread().getName().equals("微信")) {
			account.drawing(money);
		}else {
			account.drawing1(money);
		}
		
	}
}

运行结果：

在这里插入图片描述

运行结果和上一段相同
说明：锁死的是 Account a 这个对象

普通方法加同步锁，锁的是当前方法对应的对象，当前的对象的所有加了同步锁的方法是共用一个同步锁

不同的对象是不同的锁

举例：

package day15;

public class Test2 {
	public static void main(String[] args) {
		
		//定义账户对象
		Account a = new Account();
		Account a1 = new Account();
		
		//多线程对象
		User u_weixin = new User(a, 2000);
		User u_zhifubao = new User(a1, 2000);
		
		Thread weixin = new Thread(u_weixin, "微信");
		Thread zhifubao = new Thread(u_zhifubao, "支付宝");
		
		weixin.start();
		zhifubao.start();
		
		
	}

}

class Account{
	public static int money = 3000;//全局变量，所有操作共享这个变量
	
	/**
	 * 提款先判断账户钱够不够
	 * 多线程调用这个方法就有问题，线程共享资源时，一个线程在执行这个方法没有完毕时，另一个线程又开始执行这个方法
	 * 解决思路：先让一个线程整体执行完这个方法，另一个线程再执行。
	 * 通过 synchronized同步锁 来完成
	 * 可以直接在方法上加上synchronized关键字
	 * 在普通方法上加同步锁synchronized，锁的是整个对象，不是某一个方法，
	 * 不同的对象是不同的锁，普通方法中加synchronized，线程使用不同的此方法的对象，还是有资源共享的问题
	 * @param m
	 */
	public synchronized void drawing(int m) {
		String name = Thread.currentThread().getName();
		
		if(money < m) {
			System.out.println(name + "操作，账户金额不足：" + money);
		}else {
			System.out.println(name + "操作，账户原有金额：" + money);
			System.out.println(name + "操作，取款金额：" + m);
			
			money = money - m;
			
			System.out.println(name + "操作，取款后的余额：" + money);
		}
		
	}
	
	public synchronized void drawing1(int m) {
		String name = Thread.currentThread().getName();
		
		if(money < m) {
			System.out.println(name + "操作，账户金额不足：" + money);
		}else {
			System.out.println(name + "操作，账户原有金额：" + money);
			System.out.println(name + "操作，取款金额：" + m);
			
			money = money - m;
			
			System.out.println(name + "操作，取款后的余额：" + money);
		}
		
	}
	
	
}

class User implements Runnable{
	
	Account account;
	int money;
	
	public User(Account account, int money) {
		this.account = account;
		this.money = money;
	}
	
	@Override
	public void run() {
	
		if(Thread.currentThread().getName().equals("微信")) {
			account.drawing(money);
		}else {
			account.drawing1(money);
		}
		
	}
}

运行结果：

在这里插入图片描述

如何解决上述问题：

举例：

package day15;

public class Test2 {
	public static void main(String[] args) {
		
		//定义账户对象
		Account a = new Account();
		Account a1 = new Account();
		
		//多线程对象
		User u_weixin = new User(a, 2000);
		User u_zhifubao = new User(a1, 2000);
		
		Thread weixin = new Thread(u_weixin, "微信");
		Thread zhifubao = new Thread(u_zhifubao, "支付宝");
		
		weixin.start();
		zhifubao.start();
		
		
	}

}

class Account{
	public static int money = 3000;//全局变量，所有操作共享这个变量	
	
	/**
	 * 静态方法 + synchronized，对于所有的对象都是使用同一个锁
	 * @param m
	 */
	public static synchronized void drawing2(int m) {
		String name = Thread.currentThread().getName();
		
		if(money < m) {
			System.out.println(name + "操作，账户金额不足：" + money);
		}else {
			System.out.println(name + "操作，账户原有金额：" + money);
			System.out.println(name + "操作，取款金额：" + m);
			
			money = money - m;
			
			System.out.println(name + "操作，取款后的余额：" + money);
		}
		
	}
}

class User implements Runnable{
	
	Account account;
	int money;
	
	public User(Account account, int money) {
		this.account = account;
		this.money = money;
	}
	
	@Override
	public void run() {

		account.drawing2(money);//调用类的静态方法
	}
}

运行结果：

在这里插入图片描述

锁代码块

举例：

package day15;

public class Test2 {
	public static void main(String[] args) {
		
		//定义账户对象
		Account a = new Account();
		Account a1 = new Account();
		
		//多线程对象
		User u_weixin = new User(a, 2000);
		User u_zhifubao = new User(a, 2000);
		
		Thread weixin = new Thread(u_weixin, "微信");
		Thread zhifubao = new Thread(u_zhifubao, "支付宝");
		
		weixin.start();
		zhifubao.start();	
		
	}
}

class Account{
	public static int money = 3000;//全局变量，所有操作共享这个变量
				
	/**
	 * 对代码块加入同步锁
	 * 代码块synchronized(this)，所有当前的对象的synchronized(this)同步的代码都是使用同一个锁
	 * @param m
	 */
	public void drawing3(int m) {
		
		synchronized(this) {//表示当前对象的代码块被加了synchronized同步锁
			//用this锁代码块是代表当前的对象，如果在其他的方法中也有synchronized(this)的代码块，使用的都是同一个同步锁
			String name = Thread.currentThread().getName();
			
			if(money < m) {
				System.out.println(name + "操作，账户金额不足：" + money);
			}else {
				System.out.println(name + "操作，账户原有金额：" + money);
				System.out.println(name + "操作，取款金额：" + m);
				
				money = money - m;
				
				System.out.println(name + "操作，取款后的余额：" + money);
			}
		}
	}
	
}

class User implements Runnable{
	
	Account account;
	int money;
	
	public User(Account account, int money) {
		this.account = account;
		this.money = money;
	}
	
	@Override
	public void run() {

		account.drawing3(money);
	}
}

运行结果：

在这里插入图片描述

如果在其他的方法中也有synchronized(this)的代码块，使用的都是同一个同步锁

举例：

package day15;

public class Test2 {
	public static void main(String[] args) {
		
		//定义账户对象
		Account a = new Account();
		
		//多线程对象
		User u_weixin = new User(a, 2000);
		User u_zhifubao = new User(a, 2000);
		
		Thread weixin = new Thread(u_weixin, "微信");
		Thread zhifubao = new Thread(u_zhifubao, "支付宝");
		
		weixin.start();
		zhifubao.start();
	}
}

class Account{
	public static int money = 3000;//全局变量，所有操作共享这个变量
	
	/**
	 * 对代码块加入同步锁
	 * @param m
	 */
	public void drawing3(int m) {
		
		synchronized(this) {//表示当前对象的代码块被加了synchronized同步锁
			//用this锁代码块是代表当前的对象，如果在其他的方法中也有synchronized(this)的代码块，使用的都是同一个同步锁
			String name = Thread.currentThread().getName();
			
			if(money < m) {
				System.out.println(name + "操作，账户金额不足：" + money);
			}else {
				System.out.println(name + "操作，账户原有金额：" + money);
				System.out.println(name + "操作，取款金额：" + m);
				
				money = money - m;
				
				System.out.println(name + "操作，取款后的余额：" + money);
			}
		}
	}
	
	
	public void drawing4(int m) {
		
		synchronized(this) {//表示当前对象的代码块被加了synchronized同步锁
			//用this锁代码块是代表当前的对象，如果在其他的方法中也有synchronized(this)的代码块，使用的都是同一个同步锁
			String name = Thread.currentThread().getName();
			
			if(money < m) {
				System.out.println(name + "操作，账户金额不足：" + money);
			}else {
				System.out.println(name + "操作，账户原有金额：" + money);
				System.out.println(name + "操作，取款金额：" + m);
				
				money = money - m;
				
				System.out.println(name + "操作，取款后的余额：" + money);
			}
		}
	}

}

class User implements Runnable{
	
	Account account;
	int money;
	
	public User(Account account, int money) {
		this.account = account;
		this.money = money;
	}
	
	@Override
	public void run() {

		if(Thread.currentThread().getName().equals("微信")) {
			account.drawing3(money);
		}else {
			account.drawing4(money);
		}
		
		
	}
}

运行结果：

在这里插入图片描述

怎么使用不同的同步锁

举例：
（1）锁同一个对象，设置a、a1两个账户

package day15;

public class Test2 {
	public static void main(String[] args) {
		
		//定义账户对象
		Account a = new Account();
		Account a1 = new Account();
		
		//多线程对象
		User u_weixin = new User(a, 2000);
		User u_zhifubao = new User(a1, 2000);
		
		Thread weixin = new Thread(u_weixin, "微信");
		Thread zhifubao = new Thread(u_zhifubao, "支付宝");
		
		weixin.start();
		zhifubao.start();
		
		
	}

}

class Account{
	public static int money = 3000;//全局变量，所有操作共享这个变量
	
	/**
	 * synchronized修饰代码块，想要根据不同的对象有不同的锁
	 * @param m
	 */
	public void drawing5(int m, Account a) {
		
		synchronized(a) {//表示通过方法的参数传递进来的对象的代码块被加了synchronized同步锁
			//不同的对象就有不同的同步锁
			String name = Thread.currentThread().getName();
			
			if(money < m) {
				System.out.println(name + "操作，账户金额不足：" + money);
			}else {
				System.out.println(name + "操作，账户原有金额：" + money);
				System.out.println(name + "操作，取款金额：" + m);
				
				money = money - m;
				
				System.out.println(name + "操作，取款后的余额：" + money);
			}
		}
	}
	
}

class User implements Runnable{
	
	Account account;
	int money;
	
	public User(Account account, int money) {
		this.account = account;
		this.money = money;
	}
	
	@Override
	public void run() {
		
		account.drawing5(money, account);	
	}
}

运行结果：

在这里插入图片描述

（2）锁同一个对象，只设置a一个账户

package day15;

public class Test2 {
	public static void main(String[] args) {
		
		//定义账户对象
		Account a = new Account();
		
		//多线程对象
		User u_weixin = new User(a, 2000);
		User u_zhifubao = new User(a, 2000);
		
		Thread weixin = new Thread(u_weixin, "微信");
		Thread zhifubao = new Thread(u_zhifubao, "支付宝");
		
		weixin.start();
		zhifubao.start();
		
	}
}

class Account{
	public static int money = 3000;//全局变量，所有操作共享这个变量

	/**
	 * synchronized修饰代码块，想要根据不同的对象有不同的锁
	 * synchronized(a)这个小括号中传入不同的对象就是不同的锁
	 * @param m
	 */
	public void drawing5(int m, Account a) {
		
		synchronized(a) {//表示通过方法的参数传递进来的对象的代码块被加了synchronized同步锁
			//不同的对象就有不同的同步锁
			String name = Thread.currentThread().getName();
			
			if(money < m) {
				System.out.println(name + "操作，账户金额不足：" + money);
			}else {
				System.out.println(name + "操作，账户原有金额：" + money);
				System.out.println(name + "操作，取款金额：" + m);
				
				money = money - m;
				
				System.out.println(name + "操作，取款后的余额：" + money);
			}
		}
	}
	
	
	
}

class User implements Runnable{
	
	Account account;
	int money;
	
	public User(Account account, int money) {
		this.account = account;
		this.money = money;
	}
	
	@Override
	public void run() {
		
		account.drawing5(money, account);
	}
}

运行结果：

在这里插入图片描述

3. 线程的死锁问题

问题情景：
    线程a0，需要执行方法f0
    线程a1，需要执行方法f1
    f0和f1都是有同步锁的方法
    a0调用f1方法并且一直没有执行完f1
    a1调用f0方法并且一直没有执行完f0
    
导致a0和a1线程都在等待对方释放方法，对方都不释放，这样就形成了线程的死锁

死锁：
    不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

解决方法：
    ①专门的算法、原则，比如加锁顺序一致
    ②尽量减少同步资源的定义，尽量避免锁未释放的场景

Cpdr
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java多线程：线程同步详解
流楚丶格念的博客
07-16 3049
线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行。
JAVA多线程之线程同步
qq_39367410的博客
10-09 2967
线程同步、并发的基本概念以及解决问题的三种方法
Java 线程同步与死锁 学习笔记
激流小舟的博客
09-25 4003
Java 线程同步与死锁 学习笔记Java 线程同步与死锁 学习笔记 1 多线程共享数据 2 线程同步 3 同步准则 4 线程死锁 1、 多线程共享数据 在多线程操作中，多个线程可能同时处理同一个资源，这就是多线程中的共享数据。如：在对数据库进行操作中，有可能同时会有多个线程同时对某个数据进行操作 eg:public class MyThread implements Runnable{
Java多线程 线程同步与死锁
YangLe
02-25 6407
1.线程同步多线程引发的安全问题一个非常经典的案例，银行取钱的问题。假如你有一张银行卡，里面有5000块钱，然后你去银行取款2000块钱。正在你取钱的时候，取款机正要从你的5000余额中减去2000的时候，你的老婆正巧也在用银行卡对应的存折取钱，由于取款机还没有把你的2000块钱扣除，银行查到存折里的余额还剩5000块钱，准备减去2000。这时，有趣的事情发生了，你和你的老婆从同一个账户共取走了40
JAVA线程—同步与死锁
小熊来了
03-11 2782
【TX】前言：在 http://blog.csdn.net/tangmingxin0529/article/details/79514849 这篇文章中我们了解了JAVA多线程的一些概念及常用方法。我们已经知道，一个多线程的程序如果是通过Runnable接口实现的，则意味着类中的属性将被多个线程共享，那么这样一来就会出现资源的同步问题。先看2个例子：例1：启用3个售票线程public class ...
Java多线程——死锁
u010759175的专栏
12-28 1068
话不多说先来个例子说明 灰姑娘和白雪公主化妆，但是同时拿着对方的资源不释放，形成了僵持的局面 //死锁：多个线程互相抱着对方需要的资源，形成僵持 public class DeadLock { public static void main(String[] args) { MakeUp m1 = new MakeUp(0,"灰姑娘"); MakeUp m2 = new MakeUp(1,"白雪公主"); m1.start(); m2.start(); } } //口红 class
Java 线程安全、线程同步、互斥锁、Lock锁、死锁、线程间通信
一只文森特
04-25 1514
Java 线程安全、线程同步、互斥锁、Lock锁、死锁、线程间通信
Java多线程——死锁的成因与解决
weixin_60778429的博客
08-02 2415
死锁是指两个或者两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造的一种阻塞的现象，若无外力作用，他们都将无法推进下去。. 假设有 N 个线程尝试获取 M 把锁, 就可以针对 M 把锁进行编号 (1, 2, 3...M). N 个线程尝试获取锁的时候, 都按照固定的按编号。即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。当然预防出现死锁的方法不止一种，我们只是讲了一种比较简单易懂的方法。的进程称为死锁进程。即当资源请求者在请求其他的资源的同时保持对原有资源的占有。.
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 40万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Java笔试面试-线程与死锁
HenryLei的博客
09-20 4万+
线程   线程（Thread）是程序运行的执行单元，依托于进程存在。一个进程中可以包含多个线程，多线程可以共享一块内存空间和一组系统资源，因此线程之间的切换更加节省资源、更加轻量化，因而也被称为轻量级的进程。 进程   进程（Processes）是程序的一次动态执行，是系统进行资源分配和调度的基本单位，是操作系统运行的基础，通常每一个进程都拥有自己独立的内存空间和系统资源。简单来说，进程可以被当做...
JAVA_线程同步与死锁
08-16
一个详细讲解JAVA_线程同步与死锁的例子 希望可以帮助到你。
Java实现线程死锁
01-20
　春节的时候去面试了一家公司，笔试题里面有一道是使用简单的代码实现线程的‘死锁’，当时没有想到这道题考的是Synchronized关键字，于是自己定义了两个资源模拟了一下。后面想想肠子都悔青了，于是自己在电脑上...
Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
02-02
Java多线程--避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
Java线程的同步与死锁
09-14
描述Java线程的同步与死锁，加深了解同步与死锁的问题
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 991
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 789
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 291
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 257
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
java 多线程怎么解决死锁
05-11
在Java中，死锁是由于线程之间互相持有对方需要的锁而导致的一种阻塞状态。解决死锁的常用方法有以下几种： 1.避免死锁：在编程时尽量避免出现死锁情况，例如按照固定的顺序获得锁，不要嵌套多层同步块，避免一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Cpdr

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值