线程

最新推荐文章于 2021-03-04 09:26:16 发布

jianyan__

最新推荐文章于 2021-03-04 09:26:16 发布

阅读量142

点赞数

分类专栏： java 文章标签： javaSE多线程

本文链接：https://blog.csdn.net/jianyan__/article/details/103264030

版权

java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

线程

线程概述

进程：计算机中特定功能的程序再数据集上的一次运行。

线程：线程是进程的一个单元。

多线程：一个进程中有多个线程在同时运行，例如迅雷下载，迅雷软件的一次运行就是一个进程，那么在迅雷中可以同时下载多个电影，这就是多线程（每一个下载都是一个线程）；

多线程的优势

 多线程使系统空转时间减少，提高CPU利用率

 进程间不能共享内存，但线程之间共享内存非常容易

 使用多线程实现多任务并发比多进程的效率高

 Java语言内置多线程功能支持，简化了Java的多线程编程

 和进程相比，它是一种非常"节俭"的多任务操作方式。

 线程间方便的通信机制。

 提高应用程序响应。

 使多CPU系统更加有效。

 改善程序结构。

java所有的操作都是由线程去完成的

常用方法

方法	类型	描述
Thread Thread.currentThread	静态	获取正在运行的线程对象
String 线程对象.set/getName	普通	设置/获取线程名
void 线程对象.start（线程进入就绪状态等cpu翻牌子）	普通	开启线程对象进入就绪状态、运行完进入死亡状态
void Thread.sleep(时间单位毫秒)	静态	线程休眠（线程阻塞）
线程对象.set/getPriority§	普通	设置/获取线程的优先级（概率大小）
线程对象. join()	普通	线程加入，阻塞指定线程等到另一个线程完成以后再继续执行
Thread.yield()	静态	让当前正在执行的线程暂停，该方法不会阻塞线程，而是将线程转入可运行状态
线程对象.setDaemon()	普通	可以将指定的线程设置成后台线程, 将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。

如何创建线程

线程的实现

①创建新执行线程有两种方法。一种方法是将类声明为Thread的子类。该子类应重写Thread类的run方法。接下来可以分配并启动该子类的实例。

线程启动的时候使用线程的start方法而不是run。

run方法就是线程启动后要执行的方法

线程实现的第二种方式

②实现Runnable接口来创建线程

Thread td=new Thread(Runnable实现类的对象);

线程的生命状态

– Thread thread =new Thread（）新生状态：新建一个线程

--thread.start() 就绪状态：获取cpu资源进入运行状态 等待cpu资源调用

运行状态：cpu时间片结束进入就绪状态 cpu调用线程

--		阻塞状态：休眠、线程调度、线程通信等等都会进入阻塞状态   休眠时间到了或被唤醒等会进入就绪          								**不可运行状态**

– 死亡状态：线程结束

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，

有几种状态呢？在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态：

这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解析

线程状态	导致该状态发生的条件
NEW(新建)	线程刚被创建，但是并未启动。还没调用start方法。
Runnable(可运行)	线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。
Blocked(锁阻塞)	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限等待)	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting(计时等待)	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、 Object.wait这一状态。
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

并发同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。

要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制

(synchronized)来解决。

根据案例简述：

窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码

去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU 资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制。

那么怎么去使用呢？有三种方式完成同步操作：北京市昌平区建材城西路金燕龙办公楼一层电话：400-618-9090

\1. 同步代码块。

\2. 同步方法。

\3. 锁机制。

2.3 同步代码块

同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

格式:

synchronized(同步锁){

需要同步操作的代码

}

同步锁:

对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

\1. 锁对象可以是任意类型。

\2. 多个线程对象要使用同一把锁。

注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着

(BLOCKED)。

2.4 同步方法

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外

等着。

格式：

public synchronized void method(){

可能会产生线程安全问题的代码

}

同步锁是谁?

对于非static方法,同步锁就是this。

对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

2.5 Lock锁

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,

同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

public void lock() :加同步锁。

这之间的代码执行完别的线程才可以抢cpu

public void unlock() :释放同步锁。

线程间通信

为什么要处理线程间通信：

多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们

希望他们有规律的执行, 那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。

如何保证线程间通信有效利用资源：

多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。就

是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效

的利用资源。而这种手段即—— 等待唤醒机制。

什么是等待唤醒机制

这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争（race），比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。就好比在公司里你和你的同事们，你们可能存在在晋升时的竞争，但更多时候你们更多是一起合作以完成某些任务。

就是在一个线程进行了规定操作后，就进入等待状态（wait()），等待其他线程执行完他们的指定代码过后再将

其唤醒（notify()）;在有多个线程进行等待时，如果需要，可以使用 notifyAll()来唤醒所有的等待线程。

wait/notify 就是线程间的一种协作机制。

等待唤醒中的方法

**\1. wait：**线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时

的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象

上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中

**\2. notify：**则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先

入座。

**\3. notifyAll：**则释放所通知对象的 wait set 上的全部线程。

调用wait和notify方法需要注意的细节

\1. wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对

象调用的wait方法后的线程。

\2. wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继

承了Object类的。

\3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方

法。

优先级

------- 线程优先级：

优先级概述

每个线程执行时都具有一定的优先级。当调度线程时，会优先考虑级别高的线程

 默认情况下，一个线程继承其父线程的优先级

 使用线程对象.setPriority§来改变线程的优先级

 线程优先级为1~10之间的正整数。

线程默认优先级是5，Thread类中有三个常量，定义线程优先级范围如下：

static int MAX_PRIORITY 线程可以具有的最高优先级

static int MIN_PRIORITY 线程可以具有的最低优先级

static int NOPM_PRIORITY 线程可以具有的最低优先级

优先级影响CPU在线程间切换，切换的原则是：

 当一个线程通过显式放弃、睡眠或者阻塞、自愿释放控制权时，所有线程均接受检查而

优先级高线程将会优先执行

 一个线程可以被一个高优先级的线程抢占资源

 同级别的线程之间，则通过控制权的释放，确保所有的线程均有机会运行。

加入线程

让出线程

守护线程

死锁

产生死锁的条件：
1.有至少一个资源不能共享
2.至少有一个任务必须持有一个资源并且等待获取另一个被别的任务持有的资源
3.资源不能任务抢占
4.必须有循环等待
只要打破其中一个条件就不会产生死锁，通常是打破第4个条件

Java死锁程序

public class DeadLock {
	Object o1 = new Object();
	Object o2 = new Object();
	boolean flag = false;

	class T1 extends Thread {
		public void run() {
			System.out.println("ent T1");
			synchronized (o1) {
				System.out.println("get o1");
				try {
					this.sleep(3000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				synchronized (o2) {
					System.out.println("get o2");
				}
			}
			System.out.println("ext T1");
		}
	}

	class T2 extends Thread {
		public void run() {			
			System.out.println("ent T2");			
			synchronized (o2) {				
				System.out.println("get o2");				
				try {					this.sleep(3000);			
				} catch (InterruptedException e) {					
					// TODO Auto-generated catch block					
					e.printStackTrace();				
					}				
				synchronized (o1) {				
					System.out.println("get o1");				
					}			
				}			
			System.out.println("ext T2");		
			}	
	} 	
	public static void main(String[] args) {		
		DeadLock mt = new DeadLock();		
		DeadLock.T1 t1 = mt.new T1();		
		DeadLock.T2 t2 = mt.new T2();		
		t1.start();		
		t2.start();	}
	}