多线程-入门

最新推荐文章于 2024-10-01 18:51:18 发布

小张8694

最新推荐文章于 2024-10-01 18:51:18 发布

阅读量209

点赞数

文章标签：多线程 java

本文链接：https://blog.csdn.net/awsl8694/article/details/108027098

版权

线程(Thread)

概念

进程是系统分配资源的最小单位，线程是系统调度的最小单位。一个进程内的线程之间是可以共享资源的。
每个进程至少有一个线程存在，即主线程.

多线程优势:察多线程在一些场合下是可以提高程序的整体运行效率的。

创建线程

继承Thread类
实现Runable接口

继承Thread类
可以通过继承 Thread 来创建一个线程类，该方法的好处是 this 代表的就是当前线程，不需要通过 Thread.currentThread() 来获取当前线程的引用。

class MyThread extends Thread {    
	@Override    
	public void run() {        
		System.out.println("这里是线程运行的代码");    
	} 
} 
MyThread t = new MyThread(); 
t.start();  // 线程开始运行

实现Runable接口
通过实现 Runnable 接口，并且调用 Thread 的构造方法时将 Runnable 对象作为 target 参数传入来创建线程对象。该方法的好处是可以规避类的单继承的限制；但需要通过 Thread.currentThread() 来获取当前线程的引用。

class MyRunnable implements Runnable {    
	@Override    
	public void run() {        
		System.out.println(Thread.currentThread().getName() + "这里是线程运行的代码");    
	} 
}

其他变形–创建线程

// 使用匿名类创建 Thread 子类对象 
Thread t1 = new Thread() {     
	@Override     
	public void run() {         
		System.out.println("使用匿名类创建 Thread 子类对象");     
	} 
}; 
 
// 使用匿名类创建 Runnable 子类对象 
Thread t2 = new Thread(new Runnable() {     
	@Override     
	public void run() {         
		System.out.println("使用匿名类创建 Runnable 子类对象");     
	} 
}); 
 
// 使用 lambda 表达式创建 Runnable 子类对象 
Thread t3 = new Thread(() -> System.out.println("使用匿名类创建 Thread 子类对象")); 
Thread t4 = new Thread(() -> {     
	System.out.println("使用匿名类创建 Thread 子类对象"); 
});

Thread类及常见方法

Thread 类是 JVM 用来管理线程的一个类，换句话说，每个线程都有一个唯一的 Thread 对象与之关联。

每个执行流，也需要有一个对象来描述，而 Thread 类的对象就是用来描述一个线程执行流的，JVM 会将这些 Thread 对象组织起来，用于线程调度，线程管理。

Thread 的常见构造方法

方法	说明
Thread()	创建线程对象
Thread(Runnable target)	使用 Runnable 对象创建线程对象
Thread(String name)	创建线程对象，并命名
Thread(Runnable target, String name)	使用 Runnable 对象创建线程对象，并命名
【了解】Thread(ThreadGroup group, Runnable target)	线程可以被用来分组管理，分好的组即使线程组，这个目前我们了解即可

Thread t1 = new Thread(); 
Thread t2 = new Thread(new MyRunnable()); 
Thread t3 = new Thread("这是我的名字"); 
Thread t4 = new Thread(new MyRunnable(), "这是我的名字");

Thread 的几个常见属性

属性	获取方法
ID	getId()
名称	getName()
状态	getState()
优先级	getPriority()
是否后台线程	isDaemon()
是否存活	isAlive()
是否被中断	isInterrupted()

ID 是线程的唯一标识，不同线程不会重复
名称是各种调试工具用到
状态表示线程当前所处的一个情况，下面我们会进一步说明
优先级高的线程理论上来说更容易被调度到
关于后台线程，需要记住一点：JVM会在一个进程的所有非后台线程结束后，才会结束运行。
是否存活，即简单的理解，为 run 方法是否运行结束了
线程的中断问题，下面我们进一步说明

启动一个线程-start()

之前我们已经看到了如何通过覆写 run 方法创建一个线程对象，但线程对象被创建出来并不意味着线程就开始运行了。

覆写 run 方法是提供给线程要做的事情的指令清单
线程对象可以认为是把李四、王五叫过来了
而调用 start() 方法，就是喊一声：”行动起来！“，线程才真正独立去执行了.

一定要注意 run 方法和 start 方法是不同的，启动线程必须要调用 start 方法。

中断一个线程

目前常见的有以下两种方式：

通过共享的标记来进行沟通
调用 interrupt() 方法来通知

重点说明下第二种方法：

通过 thread 对象调用 interrupt() 方法通知该线程停止运行
thread 收到通知的方式有两种：
1. 如果线程调用了 wait/join/sleep 等方法而阻塞挂起，则以 InterruptedException 异常的形式通知，清除中断标志
2. 否则，只是内部的一个中断标志被设置，thread 可以通过
1. Thread.interrupted() 判断当前线程的中断标志被设置，清除中断标志
2. Thread.currentThread().isInterrupted() 判断指定线程的中断标志被设置，不清除中断标志

第二种方式通知收到的更及时，即使线程正在 sleep 也可以马上收到。

方法	说明
public void interrupt()	中断对象关联的线程，如果线程正在阻塞，则以异常方式通知，否则设置标志位
public static boolean interrupted()	判断当前线程的中断标志位是否设置，调用后清除标志位
public boolean isInterrupted()	判断对象关联的线程的标志位是否设置，调用后不清除标志位

等待一个线程-join()

有时，我们需要等待一个线程完成它的工作后，才能进行自己的下一步工作.
这时我们需要一个方法明确等待线程的结束。

方法	说明
public void join()	等待线程结束
public void join(long millis)	等待线程结束，最多等 millis 毫秒
public void join(long millis, int nanos)	同理，但可以更高精度

获取当前线程引用

方法	说明
public static Thread currentThread();	返回当前线程对象的引用

public class ThreadDemo {     
	public static void main(String[] args) {         
		Thread thread = Thread.currentThread();         
		System.out.println(thread.getName());     
	} 
}

休眠当前线程

因为线程的调度是不可控的，所以，这个方法只能保证休眠时间是大于等于休眠时间的。

方法	说明
public static void sleep(long millis) throws InterruptedException	休眠当前线程 millis 毫秒
public static void sleep(long millis, int nanos) throws InterruptedException	可以更高精度的休眠

public class ThreadDemo {     
	public static void main(String[] args) throws InterruptedException {         
		System.out.println(System.currentTimeMillis());         
		Thread.sleep(3 * 1000);         
		System.out.println(System.currentTimeMillis());     
	} 
}

线程状态

线程的状态是一个枚举类型 Thread.State.

public class ThreadState {     
	public static void main(String[] args) {         
		for (Thread.State state : Thread.State.values()) {             
			System.out.println(state);         
		}     
	} 
}

//输出以下状态
NEW 
RUNNABLE 
BLOCKED 
WAITING 
TIMED_WAITING 
TERMINATED

线程状态及状态转移的意义

刚把李四、王五找来，还是给他们在安排任务，没让他们行动起来，就是 NEW 状态；
当李四、王五开始去窗口排队，等待服务，就进入到 RUNNABLE 状态.该状态并不表示已经被银行工作人员开始接待，排在队伍中也是属于该状态，即可被服务的状态，是否开始服务，则看调度器的调度;
当李四、王五因为一些事情需要去忙，例如需要填写信息、回家取证件、发呆一会等等时，进入 BLOCKED 、 WATING 、 TIMED_WAITING 状态，至于这些状态的细分，以后再详解；
如果李四、王五已经忙完，为 TERMINATED 状态。

所以，之前我们学过的 isAlive() 方法，可以认为是处于不是 NEW 和 TERMINATED 的状态都是活着的。

yield() 大公无私，让出 CPU

yield() 只是让出 CPU，并不会改变自己的状态。也就上面途中，我从柜台前站起，又重新去排队去了
因为李四总是无私的让出座位，王五并不让座位，所以会导致王五的打印更多

线程安全

想给出一个线程安全的确切定义是复杂的，但我们可以这样认为：
如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的.

线程不安全原因

1.原子性

什么是原子性
我们把一段代码想象成一个房间，每个线程就是要进入这个房间的人。如果没有任何机制保证，A进入房间之后，还没有出来；B 是不是也可以进入房间，打断 A 在房间里的隐私。这个就是不具备原子性的。

那我们应该如何解决这个问题呢？是不是只要给房间加一把锁，A 进去就把门锁上，其他人是不是就进不来了。这样就保证了这段代码的原子性了。

有时也把这个现象叫做同步互斥，表示操作是互相排斥的.

一条 java 语句不一定是原子的，也不一定只是一条指令

不保证原子性会给多线程带来什么问题
如果一个线程正在对一个变量操作，中途其他线程插入进来了，如果这个操作被打断了，结果就可能是错误的。

2.可见性
主内存-工作内存

为了提高效率，JVM在执行过程中，会尽可能的将数据在工作内存中执行，但这样会造成一个问题，共享变量在多线程之间不能及时看到改变，这个就是可见性问题.

3.代码顺序性

什么是代码重排序
一段代码是这样的：

去前台取下 U 盘
去教室写 10 分钟作业
去前台取下快递

如果是在单线程情况下，JVM、CPU指令集会对其进行优化，比如，按 1->3->2的方式执行，也是没问题，可以少跑一次前台。这种叫做指令重排序

代码重排序会给多线程带来什么问题
刚才那个例子中，单线程情况是没问题的，优化是正确的，但在多线程场景下就有问题了，什么问题呢。可能快递是在你写作业的10分钟内被另一个线程放过来的，或者被人变过了，如果指令重排序了，代码就会是错误的。

synchronized 关键字-监视器锁monitor lock

synchronized的底层是使用操作系统的mutex lock实现的。

当线程释放锁时，JMM会把该线程对应的工作内存中的共享变量刷新到主内存中
当线程获取锁时，JMM会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区代码必须从主内存中读取共享变量

synchronized用的锁是存在Java对象头里的。
synchronized同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题；
同步块在已进入的线程执行完之前，会阻塞后面其他线程的进入。

锁的 SynchronizedDemo 对象

public class SynchronizedDemo {     
	public synchronized void methond() {     }     
	public static void main(String[] args) {         
		SynchronizedDemo demo = new 
		SynchronizedDemo();         
		demo.method(); 
		// 进入方法会锁 demo 指向对象中的锁；出方法会释放 demo 指向的对象中的锁     
	} 
}

锁的 SynchronizedDemo 类的对象

public class SynchronizedDemo {     
	public synchronized static void methond() {     }     
	public static void main(String[] args) {         
	method(); 
	// 进入方法会锁 SynchronizedDemo.class 指向对象中的锁；出方法会释放 SynchronizedDemo.class 指向的对象中的锁     	
	} 
}

明确锁的对象

public class SynchronizedDemo {     
	public void methond() {         
	// 进入代码块会锁 this 指向对象中的锁；出代码块会释放 this 指向的对象中的锁         
		synchronized (this) {                      
		}     
	}     
	public static void main(String[] args) {         	
		SynchronizedDemo demo = new 
		SynchronizedDemo();         
		demo.method();     
	} 
}
public class SynchronizedDemo {     
	public void methond() {         
	// 进入代码块会锁 SynchronizedDemo.class 指向对象中的锁；出代码块会释放 SynchronizedDemo.class 指向的对象中的锁         
		synchronized (SynchronizedDemo.class) {                    
		}     
	}     
	public static void main(String[] args) {         	
		SynchronizedDemo demo = new SynchronizedDemo();         	
		demo.method();     
	} 
}

volatile关键字

修饰的共享变量，可以保证可见性，部分保证顺序性

class ThraedDemo {     
	private volatile int n; 
}

通信-对象的等待集wait set

wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”)
notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()是唤醒所有的线程。
wait(long timeout)让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的notify()方法或 notifyAll() 方法，或者超过指定的时间量”，当前线程被唤醒(进入“就绪状态”)。

wait()方法*

其实wait()方法就是使线程停止运行。

方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法是用来将当前线程置入“预执行队列”中，并且在wait()所在的代码处停止执行，直到接到通知或被中断为止。
wait()方法只能在同步方法中或同步块中调用。如果调用wait()时，没有持有适当的锁，会抛出异常。
wait()方法执行后，当前线程释放锁，线程与其它线程竞争重新获取锁.

public static void main(String[] args) throws InterruptedException {   
	Object object = new Object();   
	synchronized (object) {    
		System.out.println("等待中...");    
		object.wait();    
		System.out.println("等待已过...");   
		}   
	System.out.println("main方法结束...");  
}

这样在执行到object.wait()之后就一直等待下去，那么程序肯定不能一直这么等待下去了。这个时候就需要使用到了另外一个方法唤醒的方法notify()。

notify()方法

notify方法就是使停止的线程继续运行。

方法notify()也要在同步方法或同步块中调用，该方法是用来通知那些可能等待该对象的对象锁的其它线程，对其发出通知notify，并使它们重新获取该对象的对象锁。如果有多个线程等待，则有线程规划器随机挑选出一个呈wait状态的线程。
在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出同步代码块之后才会释放对象锁。

注意：wait，notify必须使用在synchronized同步方法或者代码块内

notifyAll()方法

notify方法只是唤醒某一个等待线程，那么如果有多个线程都在等待中怎么办呢，这个时候就可以使用 notifyAll方法可以一次唤醒所有的等待线程

**注意：唤醒线程不能过早，如果在还没有线程在等待中时，过早的唤醒线程，这个时候就会出现先唤醒，在等待的效果了。这样就没有必要在去运行wait方法了。 **

wait和sleep对比

其实理论上 wait 和 sleep 完全是没有可比性的，因为一个是用于线程之间的通信的，一个是让线程阻塞一段时间，唯一的相同点就是都可以让线程放弃执行一段时间。用生活中的例子说的话就是婚礼时会吃糖，和家里自己吃糖之间有差别。说白了放弃线程执行只是 wait 的一小段现象。

总结下：

wait 之前需要请求锁，而wait执行时会先释放锁，等被唤醒时再重新请求锁。这个锁是 wait 对像上的 monitor lock
sleep 是无视锁的存在的，即之前请求的锁不会释放，没有锁也不会请求。
wait 是 Object 的方法 4. sleep 是 Thread 的静态方法

多线程案例

单例模式

饿汉模式

class Singleton {     
	private static Singleton instance = new Singleton();     
	private Singleton() {}     
	public static Singleton getInstance() {         
		return instance;     
	} 
}

懒汉模式–单线程版

class Singleton {     
	private static Singleton instance = null;     
	private Singleton() {}     
	public static Singleton getInstance() {         
		if (instance == null) {             
			instance = new Singleton();         
		}         
		return instance;     
	} 
}

懒汉模式–多线程版(性能低)

class Singleton {     
	private static Singleton instance = null;     
	private Singleton() {}     
	public synchronized static Singleton getInstance() {         
		if (instance == null) {             
		instance = new Singleton();         
		}         
		return instance;     
	} 
}

懒汉模式–多线程版–二次判断(性能高)

class Singleton {     
	private static volatile Singleton instance = null;     
	private Singleton() {}     
	public static Singleton getInstance() {         
		if (instance == null) {             
			synchronized (Singleton.class) {              
				if (instance == null) {                  
					instance = new 
					Singleton();                 
				}             
			}         
		}         
		return instance;     
	} 
}

阻塞式队列

生产者消费者模型

生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。
生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的.

定时器

import java.util.concurrent.PriorityBlockingQueue; 
 
public class Timer {     
	private static class TimerTask implements 
	Comparable<TimerTask> {         
		private Runnable command;         
		private long time; 
 
        private TimerTask(Runnable command, long after) {             
        	this.command = command;             
        	this.time = System.currentTimeMillis() + after;         
        } 
 
        private void run() {             
        	command.run();         
        } 
 
        @Override         
        public int compareTo(TimerTask o) {             
        	return (int)(time - o.time);         
        }     
} 
 
    private PriorityBlockingQueue<TimerTask> queue = new PriorityBlockingQueue<>();     
    private Object mailbox = new Object(); 
 
    private class Worker extends Thread {         
    	@Override         
    	public void run() {             
    		while (true) {                 
    			try {                     
    				TimerTask task = queue.take();                     
    				long ms = System.currentTimeMillis();                     
    				if (task.time > ms) {                         
    					queue.put(task);                         
    					synchronized (mailbox) {
    					 
    						mailbox.wait(task.time - ms);                         
    					}                     
    				} else {                         
    					task.run();                     
    				}                 
    			} catch (InterruptedException e) {                     
    				break;                 
    			}             
    		}         
    	}     
    } 
 
    public Timer() {         
    	Worker worker = new Worker();         
    	worker.start();     
    } 
 
    public void schedule(Runnable command, long after) {         
    	TimerTask task = new TimerTask(command, after);         
    	queue.offer(task);         
    	synchronized (mailbox) {             
    		mailbox.notify();         
    	}     
    } 
 
    public static void main(String[] args) throws InterruptedException {         
    	Timer timer = new Timer();         
    	Runnable command = new Runnable() {             
    		@Override             
    		public void run() {                 
    			System.out.println("我来了");                 
    			timer.schedule(this, 3 * 1000);             
    		}         
    	};         
    	timer.schedule(command, 3 * 1000);     
    	}
}

线程池

为什么需要线程池呢？
想象这么一个场景：
在学校附近新开了一家快递店，老板很精明，想到一个与众不同的办法来经营。店里没有雇人，而是每次有业务来了，就现场找一名同学过来把快递送了，然后解雇同学。这个类比我们平时来一个任务，起一个线程进行处理的模式。
很快老板发现问题来了，每次招聘 + 解雇同学的成本还是非常高的。老板还是很善于变通的，知道了为什么大家都要雇人了，所以指定了一个指标，公司业务人员会扩张到 3 个人，但还是随着业务逐步雇人。于是再有业务来了，老板就看，如果现在公司还没 3 个人，就雇一个人去送快递，否则只是把业务放到一个本本上，等着 3 个快递人员空闲的时候去处理。这个就是我们要带出的线程池的模式。

线程池最大的好处就是减少每次启动、销毁线程的损耗。

import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.BlockingQueue; 
public class ThreadPool {     
	private static class Worker extends Thread {     }     
	private BlockingQueue<Runnable> jobQueue;     	
	private int nCurrentThreads;     
	private int nThreads;     
	private Worker[] workers; 
	public ThreadPool(int nThreads, int nCachedJobs) {         
		this.jobQueue = new 
		ArrayBlockingQueue<>(nCachedJobs);         
		this.nCurrentThreads = 0;         
		this.nThreads = nThreads;         
		this.workers = new Worker[nThreads];     
	} 
	public void execute(Runnable command) throws InterruptedException {         
		if (nCurrentThreads < nThreads) {             
			Worker worker = new Worker();             
			workers[nCurrentThreads++] = worker;            
			 worker.start();         
		} else {             
			jobQueue.put(command);         
		}     
	} 
}