线程安全问题

最新推荐文章于 2025-01-21 10:59:24 发布

原创最新推荐文章于 2025-01-21 10:59:24 发布 · 214 阅读

0 ·

CC 4.0 BY-SA版权

java基础专栏收录该内容

20 篇文章

订阅专栏

基本概念

什么是线程？
　　线程是进程中不同的执行路径
什么是进程？
　　正在执行的程序，进程会开辟内存空间
什么是程序？
　　静止在计算机上的代码段。就是软件，指令和数据的集合。
多线程：多条不同的执行路径。
线程对象的创建方式：
　　１、通过继承的形式，创建线程对象
　　２、通过实现的形式，创建线程对象

多线程安全问题

多线程产生安全问题的原因：多个线程共同操作共享数据。
　　当多个线程共同操作共享数据时，由于在该线程操作共享数据的同时，其他的线程可能也操作共享数据，导致程序的结果与预期结果不一致的现象，称为多线程的安全问题
线程对象创建方式为，实现Runable接口的形式，创建了一个共同Account对象(相当于共享数据)，线程t和t1可以对这个进行访问

类实现接口创建线程

public class 线程安全问题 {
	public static void main(String[] args) {
		Account  a=new Account();
		Thread t=new Thread(a);
		Thread t1=new Thread(a);
		t.setName("张三");
		t1.setName("李四");
		t.start();
		t1.start();
	}
}
class Account implements Runnable{
	double balance=1000;
	@Override
	public void run() {
		if(balance>0) {
			//没取 ，可以取出1000，一次性就取1000
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			balance-=1000;
			System.out.println(Thread.currentThread().getName()+"取款后，余额为："+balance);
		}else {
			System.out.println(Thread.currentThread().getName()+"余额不足");
		}
	}
}

这个程序的运行结果不唯一
运行结果
在这里插入图片描述
正常情况应该是张三或李四取完1000后，余额为0，第二个人就不能在进行取款

张三和李四就是两个线程，1000元余额就是共享数据，两个线程并发访问共享数据，导致线程不安全问题

解决方案

1、同步方法
格式：
　　权限修饰符 synchronized 返回值类型方法名称(参数){}
2、同步代码块
格式：
　　synchronized(锁对象){
}
同步代码块加在共享数据外
锁对象可以是任意对象。但是必须是所有线程的共享对象，对所有线程有效
同步代码块里的（）可以填写类、this、静态对象、任意实例对象
this表示的是当前类的当前对象，条件是两个线程同时使用同一个类比如实现接口的创建线程的方式
类锁任意对象的类都只有一个唯一
锁对象为什么可以是任意实例对象，当一个线程运行到同步代码块的时候，相当于上锁，只有当这个线程执行完这段代码，释放这个实例化的对象，其他线程才能运行同步代码块里的代码
总结：
① 判断是否存在多线程的安全问题。
② 加锁是否为同一把锁。

public class 多线程安全问题的解决 {
	public static void main(String[] args) {
		Account  c=new Account();
		Thread  t=new Thread(c);
		Thread  t1=new Thread(c);
		t.setName("张三");
		t1.setName("李四");
		t.start();
		t1.start();
	}
}
class Account implements Runnable{
	double balance=1000;
	Object  o=new Object();
	@Override
	public /*synchronized*/ void run() {
//		错误的
//		synchronized (new Object()) {
		//this锁
//		synchronized (this) {
		synchronized (this) {
			if (balance > 0) {
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				balance -= 1000;
				System.out.println(Thread.currentThread().getName() + "取款后，余额为：" + balance);
			} else {
				System.out.println(Thread.currentThread().getName() + "余额不足");
			}
		}
	}
}

类继承Thread类创建线程

使用继承方式创建线程，每个线程都是单独实例化类而创建的对象，所以不存在共享数据，每个数据都是该对象私有的。
解决多线程不安全的方法是给方法或代码块加锁，这个锁必须是线程都能够访问的，不是线程对象私有的。对于继承Thread类创建的线程来说，我们要创建一个静态的锁static Object o = new Object();

public class 多线程安全继承加锁 {

	public static void main(String[] args) {
		Account a1 = new Account();
		Account a2 = new Account();
		a1.setName("张三");
		a2.setName("李四");
		a1.start();
		a2.start();
	}

}
class Account extends Thread{
	double balance=1000;
	Object o = new Object();
	public void run() {
		synchronized (o) {
			if (balance>0) {
				try {
					Thread.sleep(100);
				} catch (Exception e) {
					e.printStackTrace();
				}
				balance=balance-1000;
				System.out.println(Thread.currentThread().getName()+"成功取款，余额为："+balance);
			}else {
				System.out.println(Thread.currentThread().getName()+"取款余额不足，余额为"+balance);
			}
		}
		
	}
}

上面代码没有共享数据，balance属于每个线程私有，不存在多线程访问共享数据，不会产生线程安全问题。
但是把balance改成静态，即变成共享数据，会发生线程不安全，这个时候在进行上锁操作，上锁的锁对象也要是静态的，即多个线程都能访问，如果是非静态的，两个线程的锁就不是同一把锁。

public class 多线程安全继承加锁 {

	public static void main(String[] args) {
		Account a1 = new Account();
		Account a2 = new Account();
		a1.setName("张三");
		a2.setName("李四");
		a1.start();
		a2.start();
	}

}
class Account extends Thread{
	static double balance=1000;
	static Object o = new Object();
	public void run() {
		synchronized (o) {
			if (balance>0) {
				try {
					Thread.sleep(100);
				} catch (Exception e) {
					e.printStackTrace();
				}
				balance=balance-1000;
				System.out.println(Thread.currentThread().getName()+"成功取款，余额为："+balance);
			}else {
				System.out.println(Thread.currentThread().getName()+"取款余额不足，余额为"+balance);
			}
		}
		
	}
}