线程基础安全问题、死锁及线程间通信详解

最新推荐文章于 2024-01-12 18:59:05 发布

我也想写博客

最新推荐文章于 2024-01-12 18:59:05 发布

阅读量325

点赞数 3

文章标签： java

本文链接：https://blog.csdn.net/qq_42777071/article/details/104523683

版权

1、线程概述

1.1、基本概念

进程：正在运行的程序，负责了这个程序的内存空间分配，代表了内存中的执行区域。
线程：就是在一个进程中负责一个执行路径。
多线程：就是在一个进程中多个执行路径同时执行。
电脑上的程序同时在运行，“多任务”操作系统能同时运行多个进程（程序），但实际是由于CUP分时机制的作用，使每个进程都能循环获得自己的CUP时间片，由于轮换速度非常快，使得所有程序好象是在“同时”运行一样。与其说是快速的切换进程，还不如说是线程进行着CUP的资源争夺战。

1.2、多线程的利弊

1.2.1、多线程好处

1、解决一个进程里可以同时执行多个任务；
2、提高了资源的利用率（不是效率）；

1.2.2.、多线程弊端

1、降低了一个进程中线程的执行频率；
2、对线程进行管理需要额为的CUP开销（多线程的使用会给系统带来上下文切换的额外负担）；
3、线程死锁，较长时间的等待或资源争夺以及死锁等；
4、线程安全问题；

2、线程的创建方式

2.1、继承Thread类,方式一
步骤：
1、自定义一个类，并继承Thread类；
2、重写父类的run()方法，把自定义线程的任务代码写在run()方法里；
3、创建Thread类的子类对象，并调用start()方法启动线程；

public class BuildThread01 extends Thread{
	@Override
	public void run() {
		for(int i=0;i<100;i++){
			System.out.println("自定义线程中的方法-->"+i);
		}
	}

	public static void main(String[] args) {
		BuildThread01 thrad = new BuildThread01();
		thrad.start();
		for (int i = 0; i < 100; i++) {
			System.out.println("主线程中的方法-->"+i);
		}
	}
}

注意要点：
1、不能试着直接调用Thread子类对象的run()方法来启动线程，如果直接调用run()方法，相当于被当成一个普通的方法；
2、调用start()启动线程，线程一旦开启，就会执行run()方法里的代码；
这里额外说一点，main()方法里除了自定义线程的那一个外，还有两个线程，一个是main的主线程，另一个是GC垃圾回收器的线程。所以一个main函数里至少有两个线程；
有一个问题：重写父类run()方法的作用是什么：
每个线程都有自己的任务代码，JVM创建主线程的任务代码就是main()函数里的代码，自定义线程的任务代码就是写在run()方法中的，所以自定义线程负责了run()方法中的代码。

2.2、类实现Runnable接口，方式一
步骤:
1、自定义一个类实现Runnable接口；
2、实现Runnable接口的run()方法，把自定义线程的任务代码写在run()方法里；
3、创建Runnable实现类对象；
4、创建Thread类的对象，并且把Runnable实现类的对象作为实参传递。
5、调用Tread类对象的start()方法来启动线程；

public class BuildThread02 implements Runnable{

	@Override
	public void run() {
		for (int i = 0; i <50; i++) {
			System.out.println(Thread.currentThread().getName()+"--->"+i);
		}
	}
	
	public static void main(String[] args) {
	    //创建Runnable实现类的对象
		BuildThread02 thread02 = new BuildThread02();
		//创建Thread类的对象， 把Runnable实现类对象作为实参传递。
		Thread thread = new Thread(thread02,"狗娃");
		//调用thread对象的start方法开启线程。
		thread.start();
		for (int i = 0; i <50; i++) {
			System.out.println(Thread.currentThread().getName()+"--->"+i);
		}
	}
}

注意：
1、thread02是Runnable实现类的对象，是不具备start()方法的。

2.3、提问

问题一：Runable实现类的对象是线程对象吗？
Runable实现类的对象并不是线程对象，它只不过是一个实现了Runable接口的普通对象，不具备start()方法；只有Thread或者thread的子类，才是线程对象，具备start()方法；
问题二：为什么要把Runable实现类的对象作为实参传递给Thread对象？作用是什么？
这个我们先看一下Thread thread = new Thread(thread02,"狗娃");Thread()构造方法的源码：

 public Thread(Runnable target, String name) {
        init(null, target, name, 0);
    }

注意：构造方法里将Runable实现类的对象名称叫做target；
然后我们再看Thread的run()方法的源码：

  @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

run()方法里target正是Runable实现类的对象，也就是：thread02 ，所以target.run();就等于thread02.run();
那么我们现在来回答这个问题：把Runnable实现类的对象作为实参传递给Thread对象，作用就是把Runnable实现类的对象的run方法作为了线程的任务代码去执行了。
问题三：这两种方法一般使用哪种？
一般使用第二种，实现Runnable接口，因为java是单继承，多实现的。

3、线程的一般方法

Thread(String name) 初始化线程的名字
setName(String name) 设置线程对象的名字
getName() 获取线程对象的名字
sleep(long time) 线程睡眠的指定毫秒数，注意：sleep为静态方法，那个线程执行了sleep方法，就是那个线程进入睡眠
currentThread() 返回当前线程对象，注意：currentThread为静态方法，那个线程执行了currentThread方法，返回的就是那个线程的对象
getPriority() 返回当前线程的优先级，默认优先级为5，线程的优先级范围：[1,10];优先级越大，执行的概率越高
下面我贴一下代码，作为简单使用这几个方法的例子：

public class ThreadMethods extends Thread{
	
	public ThreadMethods(String threadName) {
		super(threadName);
	}
	@Override
	public void run() {  // 子类抛出的异常，小于等于父类的异常。
		System.out.println("自定义线程的名称01-》"+this.getName());// this.getName() == Thread.currentThread().getName()
		System.out.println("自定义线程的名称02-》"+Thread.currentThread().getName());
	/*	for(int i=0 ;i<50;i++){
			System.out.println("自定义线程---》"+i);
		}*/
		try {
			//子类抛出的异常，小于等于父类的异常。父类的run()没有抛出异常，所以子类的run()只能捕获异常
			Thread.sleep(1000); 
		} catch (InterruptedException e) {
		}
	}
	public static void main(String[] args) throws InterruptedException {
		ThreadMethods thread = new ThreadMethods("自定义线程");
		Thread.sleep(100);
		thread.setPriority(6); // 设置自定义线程的优先级
		thread.start();
		thread.setName("狗蛋");
		System.out.println("自定义线程的名称-》"+thread.getName());
		System.out.println("主线程线程的名称-》"+Thread.currentThread().getName());
		System.out.println("自定义线程的优先级-》"+thread.getPriority());
		System.out.println("主线程线程的优先级-》"+Thread.currentThread().getPriority());
//		for (int i = 0; i < 50; i++) {
//			System.out.println("主方法的线程--->"+i);
//		}
	}
}

注意：
这里我简单讲一下main()中Thread.sleep(100);的异常处理方法与自定义线程Thread.sleep(100);异常处理方式不一样，main()中是抛异常，自定义线程中是try-catch
因为java中：子类抛出的异常，小于等于父类的异常。父类的run()没有抛出异常，所以子类的run()只能捕获异常。

4、线程生命周期

这里我就直接上一张生命周期图吧
在这里插入图片描述

5、线程安全问题

5.1、线程安全问题的由因

嗯，，，我先讲一下线程安全问题的出现，看下面代码：

class SaleTicket extends Thread {
	public SaleTicket(String name) {
		super(name);
	}
	static int sum = 50
	// static Object o = new Object();
	@Override
	public void run() {
		while (true) {
				if (sum <= 0) {
					System.out.println("票售完了...");
					break;
				}
				System.out.println(Thread.currentThread().getName() + "售出了第" + sum + "号票");
				sum--;
		}
	}
}
public class ThreadSafes01 {
	public static void main(String[] args) {
		SaleTicket sale01 = new SaleTicket("一号窗口");
		SaleTicket sale02 = new SaleTicket("二号窗口");
		SaleTicket sale03 = new SaleTicket("三号窗口");
		sale01.start();
		sale02.start();
		sale03.start();
	}

}

先大概讲一下代码，这片代码是模仿车子窗口售票，创建了三个自定义线程，分别取名为一、二、三号窗口，上面这个代码是存在线程安全问题的，我截图一部分运行的结果图：
在这里插入图片描述
车站售的票是不能重复的，但是图中运行结果我们可以看到一号跟二号窗口都出售了43号票，这就是线程安全问题了。
简单讲一下出现这一问题的步骤：
1、当一号线程获取到了CUP的执行权，它走啊走，终于走到了System.out.println(Thread.currentThread().getName() + "售出了第" + sum + "号票");这一块代码，打印出了：一号窗口售出了第43号票；但就在这时，当一号线程还来不及执行sum--;它的执行权就被二号线程夺取了，所以这里要记得票数sum还是等于43。
2、现在二号线程拿到了CPU执行权，也是走啊走，在没有被其他线程夺去执行权的情况下，也是到了System.out.println(Thread.currentThread().getName() + "售出了第" + sum + "号票");这个位置，打印出了：二号窗口售出了第43号票；
基于上面步骤的解析，那么线程安全问题出现的条件是什么呢?
1、有两个或者两个以上的线程；
2、多个线程共享一个资源；
3、共享资源由多条代码组成；这条件不难理解，试想一下啊，假如我们的共享资源只有一句System.out.println(“哈哈哈哈”);那执行完不就完了吗，哪儿那么多事。

5.2、线程安全问题的解决

sun公司提供了线程同步机制来帮我们解决线程安全问题，其同步机制方法有两种：同步代码块，同步函数；

5.2.1、同步代码块

格式：

synchronized (锁对象) {
			共享资源（代码）
		}

至于具体的用法，我们以之前的模拟卖车票的代码为例，将线程共享的那一片代码，放进synchronized 的代码块里，如下：

while (true) {
			synchronized ("锁") {
				if (sum <= 0) {
					System.out.println("票售完了...");
					break;
				}
				System.out.println(Thread.currentThread().getName() + "售出了第" + sum + "号票");
				sum--;
			}
		}

这里要注意同步代码块的范围，不能连同while (true) {}这一个区域一同放入同步代码块中，如果放入的话，结果就是，只要任何一个线程进入同步代码块，就会将所有的票出售完，才释放锁对象。所以同步代码块同步的范围是需要根据自己实际的业务进行分析的。
再上一个整体的代码:

class SaleTicket extends Thread {
	public SaleTicket(String name) {
		super(name);
	}
	static int sum = 50;
	@Override
	public void run() {
		while (true) {
			synchronized ("锁") {
				if (sum <= 0) {
					System.out.println("票售完了...");
					break;
				}
				System.out.println(Thread.currentThread().getName() + "售出了第" + sum + "号票");
				sum--;
			}
		}
	}
}
public class ThreadSafes01 {
	public static void main(String[] args) {
		SaleTicket sale01 = new SaleTicket("一号窗口");
		SaleTicket sale02 = new SaleTicket("二号窗口");
		SaleTicket sale03 = new SaleTicket("三号窗口");
		sale01.start();
		sale02.start();
		sale03.start();
	}
}

同步代码块注意事项：
1、锁对象可以是任意对象；每个对象内部都维护得有状态码synchronized()就是根据这一状态码进行同步判断的。
2、锁对象得是各个线程共享且唯一的，比如用static修饰的对象；我们来做一个假设：假设多线程的锁对象不是唯一且共享的，那么就是每个线程自己内部都维护了各自的锁对象，就相当于每个对象都具有一把钥匙，那么每个线程就可以随意打开synchronized()这把锁，不用考虑其他线程的感受。所以锁对象得是各个线程共享且唯一的。
3、在同步代码块中调用sleep()方法，并不会释放锁对象，而是当线程的睡眠时间结束，并且执行完同步代码块中的方法时，才会释放锁对象。
4、只有当真的存在线程安全时，才设置同步代码块，不然会影响效率。
我在上面的代码中，使用的锁对象是"锁"这样的字符串对象，这是最简单的锁对象。因为"锁"这个已经在字符串常量池中生成，共享且唯一。

5.2.2、同步函数

同步函数：被synchronized修饰的函数，为同步函数。
我先直接讲一下同步函数的注意要点：
1、使用synchronized修饰的方法为非静态的方法时，锁对象为this对象，当前函数的调用者；
2、使用synchronized修饰的方法为静态方法时，锁对象为当前函数所属对象的字节码文件（class）;
3、同步函数同步机制的锁对象是固定的，不可以随意更改；
4、同步函数，同步的是整个方法，所以方法里的所有代码都会被同步；
再上一片代码，来讲第一条要点----->

	@Override
	public synchronized void run() {
		while (true) {
				if (sum <= 0) {
					System.out.println("票售完了...");
					break;
				}
				System.out.println(Thread.currentThread().getName() + "售出了第" + sum + "号票");
				sum--;
		}
	}

我们使用synchronized修饰非静态的run()方法，根据第一条的定义：**使用synchronized修饰的方法为非静态的方法时，锁对象为this对象；**而这里的this正是每个正在执行的线程对象，也就是说锁对象并不是唯一且共享的，所以我们的代码出现的线程安全问题，如下的执行结果：
在这里插入图片描述
然后再上一条代码解释第二条：

class SaleTicket extends Thread {
    @Override
	public void run() {
		Ticket();
	}
	public static synchronized void Ticket() {
		while (true) {
				if (sum <= 0) {
					System.out.println("票售完了...");
					break;
				}
				System.out.println(Thread.currentThread().getName() + "售出了第" + sum + "号票");
				sum--;
			}
	}
}

上面这块代码来跑售票是不规范的，无论怎么跑都是一个窗口将票全部售完，我借用这个代码讲一下锁对象是哪一个，看一下定义：使用synchronized修饰的方法为静态方法时，锁对象为当前函数所属对象的字节码文件（class）;Ticket()所属类是SaleTicket，所以**Ticket()的锁对象就是SaleTicket的字节码文件；

6、线程死锁

先直接上图，然后再解释一下图：
在这里插入图片描述
图片的意思是：狗蛋和狗娃，要看电视，只有同时拥有遥控器和电池才能打开电视。狗蛋抢到了电池，狗娃抢到了遥控器。狗蛋要狗娃给他遥控器，而狗娃要狗蛋给他电池，于是两人就僵持住了，，，
基于这个情况我们用代码模拟：

class ThreadLock extends Thread{
	
	public ThreadLock(String name){
		super(name);
	}
	
	@Override
	public void run() {
		if("狗娃".equals(Thread.currentThread().getName())){
			synchronized ("遥控器") {
				System.out.println("狗娃拿到了遥控器了,马上拿电池...");
				synchronized ("电池") {
					System.out.println("狗娃拿到了遥控器和电池,正在在愉快的看电视...");
				}
			}
		}else if ("狗蛋".equals(Thread.currentThread().getName())) {
			synchronized ("电池") {
				System.out.println("狗蛋拿到了电池了,马上拿遥控器...");
				synchronized ("遥控器") {
					System.out.println("狗蛋拿到了遥控器和电池,正在在愉快的看电视...");
				}
			}
		}
	}
}
public class DeadLock {
	public static void main(String[] args) {
		ThreadLock thread01 = new ThreadLock("狗娃");
		ThreadLock thread02 = new ThreadLock("狗蛋");
		thread01.start();
		thread02.start();
	}
}

这一片代码执行后有两种情况，一种是正常的运行，另一种则是陷入了死锁；
我们先看正常的结果：
在这里插入图片描述
我们再看一种死锁的结果：

这一结果就是狗娃在等电池，狗蛋在等遥控器的僵持状态。我们来看一下导致这一状态的原因：
首先我们创建了两个线程狗娃和狗蛋，并线程的任务代码里有两个锁对象：遥控器和电池；
然后我们来走一下代码：
1、狗娃先获得CUP的执行权，走啊走啊，走，走到了System.out.println("狗娃拿到了遥控器了,马上拿电池...");这个位置，占用着遥控器这个锁对象，当他正要准备通过电池这个锁对象去拿电池的时候，他的执行权被狗蛋抢走了。这时记住了，狗娃任然占用着遥控器这个锁对象；
2、狗蛋拿到的执行权，也是走啊走啊，走，这时由于狗娃并没有占用着电池这一锁对象，所有狗蛋轻松的通过电池这个锁对象拿到了电池。但是正当狗蛋去拿遥控器的时候，狗娃正占用着遥控器这个锁对象，所以狗蛋拿不到遥控器，并占用着电池这个锁对象。而狗娃也拿不到电池，因为狗蛋并未释放电池这个锁对象。就有了上面的死锁结果。

从上面的运行结果我们可以看出，死锁并不是一定会发生的，而是概率问题；

出现线程死锁的根本原因

1、存在两个或者两个以上的线程
2、存在两个或者两个以上的共享资源

出现线程死锁的解决方法

没有，尽量避免

7、线程之间的通讯

线程通讯：一个线程完成任务，去通知另外的线程进行其他的任务
线程通讯方法：
1、wait()：调用wait()方法的线程，将释放锁对象进入等待状态，并且只有当其他线程调用notify()方法才能被唤醒；
2、notify()：唤醒线程池中等待线程中的一个，不能唤醒指定的线程，一般先等待先唤醒；
3、notifyAll()：唤醒线程池中所以的等待线程；
wait()、notify()的注意事项:
1、wait()和notify()方法是属于Object对象的;
2、wait()和notify()必须在同步代码块或者同步函数中才能使用;
3、wait()和notify()只能由锁对象调用;
4、调用了notify()方法，即使线程池中没有等待的线程也没有关系；

提问：为什么wait()和notify()只能由锁对象调用？
1、一个线程执行了wait()方法，那么该线程就会进入到一个一锁对象为标识符的线程池中等待；
2、一个线程执行了notify()方法，那么就会唤醒以锁对象为标识符的线程池中等待的一个线程；
不同的锁调用wait()和notify()方法就创建了不同的线程池，notify()只能唤醒同一线程池里的线程；
在这里插入图片描述
我们举一个官方线程通讯的例子：生产者生产一个产品，消费者就消费一个产品，产品是生产者与消费者共享的；
使用代码模拟上述需要：

// 产品
class Product{
	String name;
	double price;
	boolean flag = false;//是否有生产的产品，默认为无
}

// 生产者
class Producer extends Thread{
	Product p; // 维护了产品
	public Producer(Product p,String name) {
		super(name);
		this.p = p;
	}
	
	@Override
	public void run() {
		int i = 0;
		while(true){
			synchronized (p) {
				try {
					if(!p.flag){  // 还未生产
						if(i%2==0){
							p.name = "橘子";
							p.price = 4.5;
						}else {
							p.name = "苹果";
							p.price = 2.0;
						}
						System.out.println(Thread.currentThread().getName()+"生产了"+p.name+"<--->价格是："+p.price);
						p.flag = true; // 已经生产产品，将判断改为有产品
						p.notify();  //  生产完毕，唤醒消费者去消费
						i++;
					}else {
						p.wait();   // 生产者进入等待状态，即等待消费者去消费
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

// 消费者
class Customers extends Thread{
	
	Product p; // 维护了产品
	
	public Customers(Product p,String name) {
		super(name);
		this.p = p;
	}
	
	@Override
	public void run() {
		while (true) {
			synchronized (p) {
				try {
					if (p.flag) {//判断是否有生产的产品
						System.out.println(Thread.currentThread().getName()+"消费了"+p.name+"<--->花费了"+p.price);
						p.flag = false;// 已经消费产品，将判断改为无产品
						p.notify();   // 唤醒生产者去生产
					}else {
						p.wait();     // 消费者进入等待状态，即等待生产者去生产
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
			}
		}
	}
}
public class ThreadCommunication {
	public static void main(String[] args) {
		Product p = new Product();
		Customers customers = new Customers(p,"消费者");
		Producer producer = new Producer(p,"生产者");
		producer.start();
		customers.start();
	}
}

上面代码一些详情在备注里说明：
1、分别有产品、消费者、生产者三个对象，并且消费者、生产者内部维护了产品这一对象；
2、由于产品是消费者和生产者共享的，所以在消费者、生产者的构造方法里有产品这一形参，在main方法中将产品对象作为实参传入到消费者、生产者中；
3、由于产品对象p是消费者、生产者共享的，所以消费者、生产者中的锁对象统一为产品P；

我也想写博客

关注

3
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
线程基础安全问题、死锁及线程间通信详解

1、线程概述1.1、基本概念进程：正在运行的程序，负责了这个程序的内存空间分配，代表了内存中的执行区域。线程：就是在一个进程中负责一个执行路径。多线程：就是在一个进程中多个执行路径同时执行。电脑上的程序同时在运行，“多任务”操作系统能同时运行多个进程（程序），但实际是由于CUP分时机制的作用，使每个进程都能循环获得自己的CUP时间片，由于轮换速度非常快，使得所有程序好象是在“同时”运...
复制链接

扫一扫