数据安全+线程锁+多线程访问临界资源时的数据安全问题

心已赠人 2024-04-20 11:19 56阅读 0赞

## 数据安全+线程锁+多线程访问临界资源时的数据安全问题 ##

### 一、线程的生命周期 ###

#### 1、新建状态 ####

> 1.在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时，它已经有了相应的内存空间和其它资源，但还处于不可运行状态。新建一个线程对象可采用线程构造方法来实现。
> 
> 2.例如：Thread thread=new Thread();

#### 2、 就绪状态 ####

> 新建线程对象后，调用该线程的start()方法就可以启动线程。当线程启动时，线程进入就绪状态。此时，线程将进入线程队列排队，等待CPU调用，这表明它已经具备了运行条件。

#### 3、运行状态 ####

> 当就绪状态的线程被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象的run()方法。run()方法定义了该线程的操作和功能。

#### 4、 阻塞状态 ####

> 一个正在执行的线程在某些特殊情况下，如被人为挂起，将让出CPU并暂时中止自己的执行，进入阻塞状态。在可执行状态下，如果调用sleep()、wait()等方法，线程都将进入阻塞状态。阻塞时，线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才可以转入就绪状态。

#### 5、死亡状态 ####

> 线程调用stop()方法时或run()方法执行结束后，线程即处于死亡状态。处于死亡状态的线程不具有继续运行的能力。

### 二、数据安全 ###

#### 需求 铁道部发布了一个售票任务，要求销售1000张票，由3个窗口进行销售 ####

请编写多线程程序来模拟这个效果

窗口001正在销售第1张票
    窗口001正在销售第2张票
    窗口002正在销售第3张票
    。。。
    窗口002正在销售第1000张票

使用线程类的方式去解决需求

问题一：三个窗口各买1000张票（一共卖了3000张票）  
出现原因：创建三个线程，每个线程都独享一份成员变量（maxTicket和curTicket）  
解决方案：三个线程共享属性（maxTicket和curTicket） — 静态属性

问题二：有些票没有卖到，有些票卖了重票  
出现原因：当前线程让curTicket自增后还没来得及输出，就退出CPU资源，其他线程又抢到资源了  
解决方案：当前线程让curTicket自增后必须输出完才能退出CPU资源

问题三：多卖了票  
出现原因：curTicket等于999时，三个线程互相抢资源，都进入到循环中  
解决方案：在锁里再判断一次

何为线程安全问题？  
多线程去操作同一个资源，就容易出现线程安全问题（脏数据）

线程安全的方式 – 加锁  
经验：多个线程想互斥住，必须使用同一把锁对象

synchronized  
同步代码块：  
synchronized(锁对象)\{//自动上锁  
…想要同步的代码…  
\}//自动解锁

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		MyThread t1 = new MyThread("窗口001");
    		MyThread t2 = new MyThread("窗口002");
    		MyThread t3 = new MyThread("窗口003");
    		
    		t1.start();
    		t2.start();
    		t3.start();
    	}
    }

public class MyThread extends Thread{
        
    
    	private static int maxTicket = 1000;//最大票数
    	private static int curTicket = 0;//当前卖出的票数
    	
    	private static Object obj = new Object();
    	
    	public MyThread(String name) {
        
    		super(name);
    	}
    	
    	@Override
    	public void run() {
        
    
    
    		while (curTicket < maxTicket) {
        
    			synchronized (obj) {
        
    				if (curTicket < maxTicket) {
        
    					curTicket++;
    					System.out.println(Thread .currentThread().getName() + "正在销售第" + curTicket + "张票");
    				}
    				if (curTicket == maxTicket) {
        
    					System.out.println(Thread.currentThread().getName()+ "票已售完");
    				}
    			}
    		}
    	}
    }

### 三、线程锁 ###

#### 1.创建线程的方式 – 线程类 ####

同步方法：
    	成员的同步方法： 锁对象 -- this 
    	public synchronized void method(){//自动上锁
    		...想要同步的代码...
    	}//自动解锁
    	
    	静态的同步方法：锁对象 -- 该类的class对象
    	public static synchronized void method(){//自动上锁
    		...想要同步的代码...
    	}//自动解锁

public class MyThread extends Thread{
        
    
    	private static int maxTicket = 1000;//最大票数
    	private static int curTicket = 0;//当前卖出的票数
    	
    	public MyThread(String name) {
        
    		super(name);
    	}
    	
    	@Override
    	public void run() {
        
    
    
    		while (curTicket < maxTicket) {
        
    			method();
    		}
    	}
    	
    	public static synchronized void method() {
        
    		if(curTicket < maxTicket){
        
    			curTicket++;
    			System.out.println(Thread.currentThread().getName() + "正在销售第" + curTicket + "张票");
    		}
    		if(curTicket == maxTicket){
        
    			System.out.println(Thread.currentThread().getName() + "票已售完");
    		}
    	}
    }

Lock -- 接口
    		//创建Lock对象 --锁对象
    		Lock lock = new ReentrantLock();
    		
    		lock.lock();//手动上锁
    		...想要同步的代码...
    		lock.unlock();//手动解锁

import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class MyThread extends Thread{
        
    
    	private static int maxTicket = 1000;//最大票数
    	private static int curTicket = 0;//当前卖出的票数
    	
    	//创建Lock对象
    	private static Lock lock = new ReentrantLock();
    	
    	public MyThread(String name) {
        
    		super(name);
    	}
    	
    	@Override
    	public void run() {
        
    
    		while (curTicket < maxTicket) {
        
    			lock.lock();//手动上锁
    			if(curTicket < maxTicket){
        
    				curTicket++;
    				System.out.println(Thread.currentThread().getName() + "正在销售第" + curTicket + "张票");
    			}
    			if(curTicket == maxTicket){
        
    				System.out.println(Thread.currentThread().getName() + "票已售完");
    			}
    			lock.unlock();//手动解锁
    			
    		}
    	}
    }

#### 2.创建线程的方式 – 任务类 ####

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		Task task = new Task();
    		
    		Thread t1 = new Thread(task,"窗口001");
    		Thread t2 = new Thread(task,"窗口002");
    		Thread t3 = new Thread(task,"窗口003");
    		
    		t1.start();
    		t2.start();
    		t3.start();
    	}
    }

public class Task implements Runnable{
        
    
    	private int maxTicket = 1000;
    	private int curTicket = 0;
    	
    	@Override
    	public void run() {
        
    		while (curTicket < maxTicket) {
        
    			synchronized (this) {
        
    				if (curTicket < maxTicket) {
        
    					curTicket++;
    					System.out.println(Thread.currentThread().getName() + "正在销售第" + curTicket + "张票");
    				}
    				if (curTicket == maxTicket) {
        
    					System.out.println(Thread.currentThread().getName() + "票已售完");
    				}
    			}
    		}
    		
    	}
    }

### 四、多线程访问临界资源时的数据安全问题 ###

#### 1.方案一 ####

public class Task implements Runnable{
        
    
    	private int maxTicket = 1000;
    	private int curTicket = 0;
    	
    	@Override
    	public void run() {
        
    		while (curTicket < maxTicket) {
        
    			method01();
    		}
    	}
    	
    	//锁对象：this
    	public synchronized void method01(){
        
    		if (curTicket < maxTicket) {
        
    			curTicket++;
    			System.out.println(Thread.currentThread().getName()+ "正在销售第" + curTicket + "张票");
    		}
    		if(curTicket == maxTicket){
        
    			System.out.println(Thread.currentThread().getName() + "票已售完");
    		}
    	}
    	
    	//锁对象：Task.class
    //	public static synchronized void method02(){
        
    		
    //		if(curTicket < maxTicket){
        
    //			curTicket++;
    //			System.out.println(Thread.currentThread().getName() + "正在销售第" + curTicket + "张票");
    //		}
    //		if(curTicket == maxTicket){
        
    //			System.out.println(Thread.currentThread().getName() + "票已售完");
    //		}
    //	}
    }

#### 2.方案二 ####

import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class Task implements Runnable{
        
    	
    	private int maxTicket = 1000;
    	private int curTicket = 0;
    	private Lock lock = new ReentrantLock();
    
    	@Override
    	public void run() {
        
    		
    		while(curTicket < maxTicket){
        
    			lock.lock();
    			if(curTicket < maxTicket){
        
    				curTicket++;
    				System.out.println(Thread.currentThread().getName() + "正在销售第" + curTicket + "张票");
    			}
    			if(curTicket == maxTicket){
        
    				System.out.println(Thread.currentThread().getName() + "票已售完");
    			}
    			lock.unlock();
    		}
    	}
    }

### 五、单例模式 ###

#### 1.懒汉式 ####

> 优点：解决资源
> 
> 缺点：线程不安全

public class Test01 {
        
    
    	public static void main(String[] args) {
        		
    	}
    }

public class A {
        
    
    	private static A a;
    	private A(){
        
    		
    	}
    	
    	public static A getInstance(){
        
    		if(a  == null){
        
    			a = new A();
    		}
    		return a;
    	}
    }

#### 2. 饿汉式 ####

> 优点：线程安全
> 
> 缺点：浪费资源

public class Test01 {
        
    
    	public static void main(String[] args) {
        	
    	}
    }

public class A {
        
    
    	private static A a = new A();
    	private A(){
        
    		
    	}
    	
    	public static A getInstance(){
        
    		return a;
    	}
    }

#### 3.线程安全式 ####

> 优点：线程安全、不浪费资源

public class Test01 {
        
    
    	public static void main(String[] args) {
        	
    	}
    }

public class A {
        
    
    	private static A a ;
    	private A(){
        
    		
    	}
    	
    	public static A getInstance(){
        
    		if (a != null) {
        
    			return a;
    		}
    		synchronized (A.class) {
        
    			if (a == null) {
        
    				a = new A();
    			}
    		}
    		return a;
    	}
    }

### 六、经典面试题 ###

#### 1.创建线程的方式 – 线程类 ####

计算任务，一个包含了2万个整数的数组，分拆了多个线程来进行并行计算，最后汇总出计算的结果。

public class Test01 {
        
    
    	public static void main(String[] args) throws InterruptedException{
        
    		
    		//创建包含了2万个整数的数组
    		int[] nums = new int[2000];
    		//初始化数组中的数据(1~20000)
    		for (int i = 0; i < nums.length; i++) {
        
    			nums[i] = i + 1;
    		}
    		
    		//创建4个线程
    		MyThread t1 = new MyThread(nums,0,5000);
    		MyThread t2 = new MyThread(nums,5000,10000);
    		MyThread t3 = new MyThread(nums,10000,15000);
    		MyThread t4 = new MyThread(nums,15000,20000);
    		
    		//启动线程
    		t1.start();
    		t2.start();
    		t3.start();
    		t4.start();
    		
    		//思路：必须让四个子线程全部执行完毕后再执行主线程（让主线程阻塞）
    		
    		//解决方案1：
    		//Thread.sleep(1000);
    		//解决方案2：
    		//while(t1.isFlag() || t2.isFlag() || t3.isFlag() || t4.isFlag()){}
    
    		//解决方案3：
    		t1.join();
    		t2.join();
    		t3.join();
    		t4.join();
    
    		//合并运行结果
    		int result = t1.getSum() + t2.getSum() + t3.getSum() + t4.getSum();
    		System.out.println("结果为：" + result);
    	}
    }

public class MyThread extends Thread{
        
    
    	private int[] nums;
    	private int startIndex;
    	private int endIndex;
    	private boolean flag = true;
    	
    	public MyThread(int[] nums, int startIndex, int endIndex) {
        
    		this.nums = nums;
    		this.startIndex = startIndex;
    		this.endIndex = endIndex;
    	}
    	
    	private int sum;
    	
    	@Override
    	public void run() {
        
    		for (int i = startIndex; i < endIndex; i++) {
        
    			sum += nums[i];
    		}
    		flag = false;
    	}
    
    	public boolean isFlag() {
        
    		return flag;
    	}
    
    	public int getSum() {
        
    		return sum;
    	}
    }

#### 2.创建线程的方式 – 任务类 ####

public class Test01 {
        
    
    	public static void main(String[] args) throws InterruptedException{
        
    		
    		//创建包含了2万个整数的数组
    		int[] nums = new int[20000];
    		
    		//初始化数组中的数据(1~20000)
    		for (int i = 0; i < nums.length; i++) {
        
    			nums[i] = i + 1;
    		}
    		
    		//创建4个任务
    		Task task1 = new Task(nums,0,5000);
    		Task task2 = new Task(nums,5000,10000);
    		Task task3 = new Task(nums,10000,15000);
    		Task task4 = new Task(nums,15000,20000);
    		
    		//创建线程
    		Thread t1 = new Thread(task1);
    		Thread t2 = new Thread(task2);
    		Thread t3 = new Thread(task3);
    		Thread t4 = new Thread(task4);
    		
    		//启动线程
    		t1.start();
    		t2.start();
    		t3.start();
    		t4.start();
    		
    		//思路：必须让四个子线程全部执行完毕后再执行主线程（让主线程阻塞）
    		t1.join();
    		t2.join();
    		t3.join();
    		t4.join();
    		
    		//合并运行结果
    		int result = task1.getSum() + task2.getSum() + task3.getSum() + task4.getSum();
    		System.out.println("结果：" + result);
    	}
    }

public class Task implements Runnable{
        
    
    	private int[] nums;
    	private int startIndex;
    	private int endIndex;
    	
    	public Task(int[] nums, int startIndex, int endIndex) {
        
    		this.nums = nums;
    		this.startIndex = startIndex;
    		this.endIndex = endIndex;
    	}
    	
    	private int sum;
    	
    	@Override
    	public void run() {
        
    		for (int i = startIndex; i < endIndex; i++) {
        
    			sum += nums[i];
    		}
    	}
    
    	public int getSum() {
        
    		return sum;
    	}
    }