JAVA第十一课:多线程

文章目录

    • 1. 多线程
    • 2. 死锁
    • 3. 线程间通信
    • 4. 线程组
    • 5. 线程池
    • 6. 定时器
    • 7. 多线程面试题

1. 多线程

(1)多进程
	进程:正在执行的应用程序。
		正在运行的程序,是系统进行资源分配和调用的独立单位。
		每一个进程都有它自己的内存空间和系统资源。
	多进程的意义?
		单进程计算机只能做一件事情。
		而我们现在的计算机都可以一边玩游戏(游戏进程),一边听音乐(音乐进程),
		所以我们常见的操作系统都是多进程操作系统。比如:Windows,Mac和Linux等,能在同一个时间段内执行多个任务。
		对于单核计算机来讲,游戏进程和音乐进程是同时运行的吗? 不是。
		因为CPU在某个时间点上只能做一件事情,计算机是在游戏进程和音乐进程间做着频繁切换,
		且切换速度很快,所以,我们感觉游戏和音乐在同时进行,其实并不是同时执行的。
		多进程的作用不是提高执行速度,而是提高CPU的使用率。
(2)多线程
	线程:进程的执行路径,执行单元,依赖于进程存在的。
		在一个进程内部又可以执行多个任务,而这每一个任务我们就可以看成是一个线程。
		线程是进程中的单个顺序控制流,是一条执行路径,是程序使用CPU的基本单位。
		一个进程如果只有一条执行路径,则称为单线程程序。
		一个进程如果有多条执行路径,则称为多线程程序。
	多线程的意义?
		多线程的作用不是提高执行速度,而是为了提高应用程序的使用率。
		而多线程却给了我们一个错觉:让我们认为多个线程是并发执行的。其实不是。
		因为多个线程共享同一个进程的资源(堆内存和方法区),但是栈内存是独立的,
		一个线程一个栈。所以他们仍然是在抢CPU的资源执行。
		一个时间点上只有能有一个线程执行。而且谁抢到,这个不一定,所以,造成了线程运行的随机性。
	
	随机性原理:
		因为多个线程不断去抢CPU的资源,CPU就在这多个线程间进行快速的切换,造成了随机性。
		
(3)并行和并发
	并行:逻辑上同时发生,指在某一个时间内同时运行多个程序
	并发:物理上同时发生,指在某一个时间点同时运行多个程序
	
(4)多线程的实现方案
	A:继承Thread类
		步骤:
		a:自定义类MyThread继承自Thread类
		b:重写run()方法
			因为run()方法封装的代码才是被线程执行的代码。
		c:创建子类对象
		d:启动线程
			启动线程使用的是那个方法呢?
			start():启动线程,并自动调用run()方法。
		
		Thread类的基本获取和设置方法
			public final String getName()
			public final void setName(String name)
			通过构造方法也可以给线程起名字
			如果没有设置名称,会有一个默认名称。Thread-编号
		如何获取main方法所在的线程名称呢?
			public static Thread currentThread()
			这样就可以获取任意方法所在的线程名称
	B:实现Runnable接口
		步骤:
		a:定义类MyRunnable实现接口Runnable
		b:重写run()方法
		c:创建MyRunnable的对象
		d:创建Thread类的对象,并把C步骤的对象作为构造参数传递
		e:启动线程
		实现接口方式的好处:
			可以避免由于Java单继承带来的局限性。
			适合多个相同程序的代码去处理同一个资源的情况,把线程同程序的代码,
			数据有效分离,较好的体现了面向对象的设计思想。
(5)常见的几个小问题
	A:为什么要重写run()方法
	B:启动线程使用的是哪个方法
	C:start()和run()方法的区别
		start:启动线程,并自动调用run()方法
		run:直接调用,仅仅是普通方法的调用
	D:一个线程能不能启动多次? 不能
	E:有了继承Thread类实现,为什么还要有实现接口的实现
	F:生命周期
	
(6)线程的调度
	假如我们的计算机只有一个 CPU,那么CPU在某一个时刻只能执行一条指令,
	线程只有得到CPU时间片,也就是使用权,才可以执行指令。
	线程调度:
		A:分时调度模型:所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间片
		B:抢占式调度模型:优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程获取的 CPU 时间片相对多一些。 
		Java使用的是抢占式调度模型。
	获取和设置线程的优先级:
		public final int getPriority()
		public final void setPriority(int newPriority)
		默认优先级是5
		优先级范围是1-10
		
(7)线程的控制
	A:线程休眠
		public static void sleep(long millis)
	B:线程加入
		public final void join()
	C:线程礼让
		public static void yield()
	D:守护线程
		当正在运行的线程都是守护线程时,Java 虚拟机退出。 
		public final void setDaemon(boolean on)
	E:中断线程
		public final void stop()
		public void interrupt()
		
(8)多线程的生命周期图(见下)
(9)通过多线程模拟电影院卖票
	A:继承Thread类
	B:实现Runnable接口
(10)通过多线程模拟电影院卖票(加入延迟)
	某电影院目前正在上映贺岁大片,共有100张票,而它有3个售票窗口售票,请设计一个程序模拟该电影院售票。
	A:相同的票卖多次
		CPU的一次执行必须是原子性操作
	B:出现了负数的票
		线程的随机性和延迟
		
(11)线程安全问题是如何产生的呢?
	A:多线程环境
	B:有共享数据
	C:多条语句操作共享数据
(12)解决方案:
	基本思想:让程序没有安全问题的环境。
	实现:把多个语句操作共享数据的代码给锁起来,让任意时刻只能有一个线程执行即可。
	A:同步代码块
		格式:
			synchronized(对象) {
				需要被同步的代码;
			}
		对象可以是任意对象
		同步可以解决安全问题的根本原因就在那个对象上,该对象如同锁的功能。

	B:同步方法: 就是把同步关键字加到方法上
		非静态	对象是this
		静态	对象是当前类的字节码文件对象
		同步的前提
		多个线程
		多个线程使用的是同一个锁对象
		
	同步的好处
		同步的出现解决了多线程的安全问题。
	同步的弊端
		当线程相当多时,因为每个线程都会去判断同步上的锁,很耗费资源,无形中会降低程序的运行效率。
	如果锁对象是this,就可以考虑使用同步方法。
	否则能使用同步代码块的尽量使用同步代码块。	

(13)查看源码,回顾前面的线程安全问题
	StringBuffer/StringBuilder
	Vector
	Hashtable
	以及Collections中的让集合同步功能。

JDK5中Lock锁的使用
	虽然我们可以理解同步代码块和同步方法的锁对象问题,
	但是我们并没有直接看到在哪里加上了锁,在哪里释放了锁,
	为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock
	Lock
		void lock()
		void unlock()
	ReentrantLock

线程的生命周期图
JAVA第十一课:多线程_第1张图片
多线程两种方式和常见小问题
JAVA第十一课:多线程_第2张图片
线程的状态转换图
JAVA第十一课:多线程_第3张图片

代码演示,以下代码按学习顺序来排列的

多线程初识

class Test{
	public static void main(String[] args){
		MyThread mt = new MyThread();
		mt.run();
		mt.run();
		System.out.println("===================");
		//2个 run()依次执行

		MyThread mt1 = new MyThread();
		MyThread mt2 = new MyThread();
		mt1.run();
		mt2.run();
		System.out.println("===================");
		//2个 MyThread()依次执行
		
		MyThread mt3 = new MyThread();
		MyThread mt4 = new MyThread();
		mt3.start();
		mt4.start();
		System.out.println("===================");
		//2个 MyThread()伪同步执行
	}
}

class MyThread extends Thread{
	@Override
	public void run(){
		for(int i=0; i<10; i++){
			System.out.println(getName()+"---hello"+i);
		}
	}
}

多线程线程名:无参+setXxx 或 带参

class Test{
	public static void main(String[] args){
		// 无参+setXxx()
		MyThread mt1 = new MyThread();
		MyThread mt2 = new MyThread();
		mt1.setName("张三");
		mt2.setName("李四");
		mt1.start();
		mt2.start();
		System.out.println("===================");

		// 带参
		MyThread mt3 = new MyThread("王五");
		MyThread mt4 = new MyThread("赵六");
		mt3.start();
		mt4.start();
		System.out.println(Thread.currentThread().getName() + "---AAA");
	
	}
}


class MyThread extends Thread{
	public MyThread() {
	}

	public MyThread(String name) {
		super(name);
	}

	@Override
	public void run(){
		for(int i=0; i<10; i++){
			System.out.println(getName()+"---hello"+i);
		}
	}
}

线程的优先级

class Test{
	public static void main(String[] args){
		ThreadPriority tp1 = new ThreadPriority();
		ThreadPriority tp2 = new ThreadPriority();
		ThreadPriority tp3 = new ThreadPriority();

		tp1.setName("tp1");
		tp2.setName("tp2");
		tp3.setName("tp3");

		//获取默认优先级
		System.out.println(tp1.getPriority());
		System.out.println(tp2.getPriority());
		System.out.println(tp3.getPriority());

		// 设置线程优先级
		// IllegalArgumentException
		// tp1.setPriority(1000);
		tp1.setPriority(1);
		tp2.setPriority(5);
		tp3.setPriority(10);
		
		System.out.println(tp1.getPriority());
		System.out.println(tp2.getPriority());
		System.out.println(tp3.getPriority());

		// 启动线程
		tp1.start();
		tp2.start();
		tp3.start();
	}
}

守护线程

class Test{
	public static void main(String[] args){
		Thread.currentThread().setName("刘备");
		ThreadDaemon td1 = new ThreadDaemon();
		ThreadDaemon td2 = new ThreadDaemon();

		td1.setName("关羽");
		td2.setName("张飞");

		// 设置守护线程:当正在运行的线程都是守护线程时,JVM退出。
		td1.setDaemon(true);
		td2.setDaemon(true);

		td1.start();
		td2.start();

		for (int x = 0; x < 5; x++) {
			System.out.println(Thread.currentThread().getName() + ":" + x);
		}
	}
}

class ThreadDaemon extends Thread{
	@Override
	public void run(){
		for(int i=0; i<10; i++){
			System.out.println(getName()+"---hello"+i);
		}
	}
}

线程加入

class Test{
	public static void main(String[] args){
		ThreadJoin tj1 = new ThreadJoin();
		ThreadJoin tj2 = new ThreadJoin();
		ThreadJoin tj3 = new ThreadJoin();

		tj1.setName("李渊");
		tj2.setName("李世民");
		tj3.setName("李元霸");

		tj1.start();
		try {
			tj1.join();//等待该线程终止
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		tj2.start();
		tj3.start();
	}
}

class ThreadJoin extends Thread {
	@Override
	public void run() {
		for (int x = 0; x < 10; x++) {
			System.out.println(getName() + ":" + x);
		}
	}
}

中断线程

import java.text.SimpleDateFormat;
import java.util.Date;

class Test{
	public static void main(String[] args){
		ThreadKill tk = new ThreadKill();
		tk.start();

		try {
			Thread.sleep(3000);
			//tk.stop();		//直接死
			tk.interrupt();	//死后还可以写遗嘱
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class ThreadKill extends Thread {
	@Override
	public void run() {
		System.out.println("开始执行:"+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));

		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
			// e.printStackTrace();
			System.out.println("我被杀死了");
		}

		System.out.println("结束执行:"+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
	}
}

线程休眠

import java.text.SimpleDateFormat;
import java.util.Date;

public class Test {
	public static void main(String[] args) {
		ThreadSleep ts1 = new ThreadSleep();
		ThreadSleep ts2 = new ThreadSleep();
		ThreadSleep ts3 = new ThreadSleep();

		ts1.setName("和珅");
		ts2.setName("秦桧");
		ts3.setName("高俅");

		ts1.start();
		ts2.start();
		ts3.start();
	}
}

class ThreadSleep extends Thread {
	@Override
	public void run() {
		for (int x = 0; x < 10; x++) {
			System.out.println(getName()+ ":"+ x+ "---"+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));

			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

礼让线程

public class Test {
	public static void main(String[] args) {
		ThreadYield ty1 = new ThreadYield();
		ThreadYield ty2 = new ThreadYield();

		ty1.setName("ty1");
		ty2.setName("ty2");

		ty1.start();
		ty2.start();
	}
}
class ThreadYield extends Thread {
	@Override
	public void run() {
		for (int x = 0; x < 10; x++) {
			System.out.println(getName() + ":" + x);
			Thread.yield();//礼让线程,暂停当前正在执行的线程对象,并执行其他线程
		}
	}
}

线程实现方案二:实现Runnable接口

/*
 * 实现Runnable接口的步骤:
 * 
 * A:定义类MyRunnable实现接口Runnable
 * B:重写run()方法
 * C:创建MyRunnable的对象
 * D:创建Thread类的对象,并把C步骤的对象作为构造参数传递
 * E:启动线程
 * 
 * 有了继承Thread类的方式,为什么还要有实现Runnable接口的方式?
 * 原因是因为类是单继承。
 */
public class Test {
	public static void main(String[] args) {
		// 创建MyRunnable的对象
		MyRunnable my = new MyRunnable();

		// 创建Thread类的对象,并把C步骤的对象作为构造参数传递
		// Thread(Runnable target)
		// Thread(Runnable target, String name)
		Thread t1 = new Thread(my, "t1");
		Thread t2 = new Thread(my, "t2");

		t1.start();
		t2.start();
	}
}

class MyRunnable implements Runnable {
	@Override
	public void run() {
		for (int x = 0; x < 10; x++) {
			System.out.println(Thread.currentThread().getName() + ":" + x);
		}
	}
}

卖票问题实现一:继承Thread

public class Test {
	public static void main(String[] args) {
		MovieTicket mt1 = new MovieTicket();
		MovieTicket mt2 = new MovieTicket();
		MovieTicket mt3 = new MovieTicket();

		mt1.setName("窗口1");
		mt2.setName("窗口2");
		mt3.setName("窗口3");

		mt1.start();
		mt2.start();
		mt3.start();
	}
}

class MovieTicket extends Thread {
	private static int tickets = 100;

	@Override
	public void run() {
		while (true) {
			if (tickets > 0) {
				System.out.println(getName() + "正在出售第" + (tickets--) + "张票");
			}
		}
	}
}

卖票问题实现二:实现Runnable 接口

public class Test {
	public static void main(String[] args) {
		MovieTicket mt = new MovieTicket();

		Thread t1 = new Thread(mt, "窗口1");
		Thread t2 = new Thread(mt, "窗口2");
		Thread t3 = new Thread(mt, "窗口3");

		t1.start();
		t2.start();
		t3.start();
	}
}

class MovieTicket2 implements Runnable {
	private int tickets = 100;

	@Override
	public void run() {
		while (true) {
			if (tickets > 0) {
				System.out.println(Thread.currentThread().getName() + "正在出售第"+ (tickets--) + "张票");
			}
		}
	}
}

考虑延时问题,加入线程睡眠,却发现以下代码出现bug

bug:
A:相同的票出现了多次
	CPU的一次操作必须是原子性的
B:还出现了负数票的情况
	随机性和延迟导致的
public class Test {
	public static void main(String[] args) {
		MovieTicket mt = new MovieTicket();

		Thread t1 = new Thread(mt, "窗口1");
		Thread t2 = new Thread(mt, "窗口2");
		Thread t3 = new Thread(mt, "窗口3");

		t1.start();
		t2.start();
		t3.start();
	}
}

class MovieTicket implements Runnable {
	private int tickets = 100;

	@Override
	public void run() {
		while (true) {
			if (tickets > 0) {
				try {
					Thread.sleep(100);// t1进来了,t2进来了,t3进来了
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

				System.out.println(Thread.currentThread().getName() + "正在出售第"+ (tickets--) + "张票");
			}
		}
	}
}
解决:
	方式一:同步代码块
	方式二:同步方法

方式一:同步代码块

public class Test {
	public static void main(String[] args) {
		MovieTicket mt = new MovieTicket();

		Thread t1 = new Thread(mt, "窗口1");
		Thread t2 = new Thread(mt, "窗口2");
		Thread t3 = new Thread(mt, "窗口3");

		t1.start();
		t2.start();
		t3.start();
	}
}

class MovieTicket implements Runnable {
	private int tickets = 100;

	@Override
	public void run() {
		while (true) {
			// t1,t2,t3
			// t1过来了,看到了同步代码块的锁标记,绿色标记(火车上厕所,过马路的红绿灯)
			// t2,t3都只能在这里等待
			synchronized (this) {
				// t1就进来了,立马修改标记为红色标记
				if (tickets > 0) {
					// 更符合现实情况
					try {
						Thread.sleep(100); // t1休息会
					} catch (InterruptedException e) {
						e.printStackTrace();
					}

					System.out.println(Thread.currentThread().getName()+ "正在出售第" + (tickets--) + "张票");
				}
			}
			// t1出来了,立马修改标记为绿色标记
		}
	}
}

方式二:同步方法

public class Test {
	public static void main(String[] args) {
		MovieTicket mt = new MovieTicket();

		Thread t1 = new Thread(mt, "窗口1");
		Thread t2 = new Thread(mt, "窗口2");
		Thread t3 = new Thread(mt, "窗口3");

		t1.start();
		t2.start();
		t3.start();
	}
}

class MovieTicket implements Runnable {
	private static int tickets = 100;
	private Object obj = new Object();
	private int x = 0;

	@Override
	public void run() {
		while (true) {
			if (x % 2 == 0) {
				synchronized (MovieTicket.class) {
					if (tickets > 0) {
						try {
							Thread.sleep(100);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}

						System.out.println(Thread.currentThread().getName()+ "正在出售第" + (tickets--) + "张票");
					}
				}
			} else {
				sellTicket();
			}
			x++;
		}
	}

	private static synchronized void sellTicket() {
		if (tickets > 0) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

			System.out.println(Thread.currentThread().getName() + "正在出售第"+ (tickets--) + "张票");
		}
	}
}

Lock锁

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/*
 * 为了更清楚的让我们知道是如何加锁和释放锁的,JDK5以后就提供了一个接口:Lock锁。
 * Lock
 * 		public void lock():加锁
 * 		public void unlock():释放锁
 * 实现类对象
 * 		public ReentrantLock()
 */
public class Test {
	public static void main(String[] args) {
		MovieTicket mt = new MovieTicket();

		Thread t1 = new Thread(mt, "窗口1");
		Thread t2 = new Thread(mt, "窗口2");
		Thread t3 = new Thread(mt, "窗口3");

		t1.start();
		t2.start();
		t3.start();
	}
}

class MovieTicket implements Runnable {
	private int tickets = 100;
	private Object obj = new Object();

	// 造锁
	// private ReentrantLock lock = new ReentrantLock();
	private Lock lock = new ReentrantLock();

	@Override
	public void run() {
		while (true) {
			try {
				lock.lock();// 加锁
				if (tickets > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+ "正在出售第" + (tickets--) + "张票");
				}
			} finally {
				lock.unlock();// 释放锁
			}
		}
	}
}

2. 死锁

同步弊端
	效率低
	如果出现了同步嵌套,就容易产生死锁问题

死锁问题
	是指两个或者两个以上的线程在执行的过程中,因争夺资源产生的一种互相等待现象
	同步代码块的嵌套
class Test {
	public static void main(String[] args) {
		//死锁:是指两个或者两个以上的线程在执行的过程中,因争夺资源产生的一种互相等待现象
		DieLock d1 = new DieLock(true);
		DieLock d2 = new DieLock(false);

		d1.start();
		d2.start();
	}
}

class MyLock {
	public static final Object objA = new Object();
	public static final Object objB = new Object();
}

class DieLock extends Thread {
	private boolean flag;

	public DieLock(boolean flag) {
		this.flag = flag;
	}

	@Override
	public void run() {
		if (flag) {
			synchronized (MyLock.objA) {
				System.out.println("if objA"); // CPU的执行权没有了
				synchronized (MyLock.objB) {
					System.out.println("if objB");
				}
			}
		} else {
			synchronized (MyLock.objB) {
				System.out.println("else objB");
				synchronized (MyLock.objA) {
					System.out.println("else objA");
				}
			}
		}   
	}
}

3. 线程间通信

针对同一个资源的操作有不同种类的线程
举例:卖票有进的,也有出的。

通过设置线程(生产者)和获取线程(消费者)针对同一个学生对象进行操作

线程间通信的代码改进
	A:通过等待唤醒机制实现数据依次出现
		wait() 		让线程处于等待
		notify()	唤醒单个线程
		notifyAll() 唤醒所有线程
	B:把同步代码块改进为同步方法实现

等待唤醒机制
JAVA第十一课:多线程_第4张图片
普通代码

public class Test {
	public static void main(String[] args) {
		Student s = new Student();

		SetThread st = new SetThread(s);
		GetThread gt = new GetThread(s);

		Thread t1 = new Thread(st);
		Thread t2 = new Thread(gt);

		t1.start();
		t2.start();
	}
}

class SetThread implements Runnable {
	private Student s;

	public SetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		s.name = "林青霞";
		s.age = 28;
	}
}

class GetThread implements Runnable {
	private Student s;
	
	public GetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		System.out.println(s.name + "---" + s.age);
	}
}

class Student {
	String name;
	int age;
}

加2个锁

public class Test {
	public static void main(String[] args) {
		Student s = new Student();

		SetThread st = new SetThread(s);
		GetThread gt = new GetThread(s);

		Thread t1 = new Thread(st);
		Thread t2 = new Thread(gt);

		t1.start();
		t2.start();
	}
}

class SetThread implements Runnable {
	private Student s;
	private int x = 0;

	public SetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (s) {
				if (x % 2 == 0) {
					s.name = "林青霞";。
					s.age = 28;
				} else {
					s.name = "刘意";
					s.age = 31;
				}
				x++;
			}
		}
	}
}

class GetThread implements Runnable {
	private Student s;

	public GetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (s) {
				System.out.println(s.name + "---" + s.age);
			}
		}
	}

}

class Student {
	String name;
	int age;
}

同步代码块 + 线程等待 & 唤醒线程

public class Test {
	public static void main(String[] args) {
		Student s = new Student();

		SetThread st = new SetThread(s);
		GetThread gt = new GetThread(s);

		Thread t1 = new Thread(st);
		Thread t2 = new Thread(gt);

		t1.start();
		t2.start();
	}
}

class SetThread implements Runnable {
	private Student s;
	private int x = 0;

	public SetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (s) {
				if (s.flag) {//表示有数据
					try {
						s.wait(); // t1就等待了
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}

				if (x % 2 == 0) {
					s.name = "林青霞";
					s.age = 28;
				} else {
					s.name = "刘意";
					s.age = 31;
				}
				x++;
				s.flag = true;
				s.notify(); //唤醒等待的线程,并不代表该线程能够立即获取CPU的执行权
			}
		}
	}
}

class GetThread implements Runnable {
	private Student s;

	public GetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (s) {
				if (!s.flag) {//如果没有数据,就等待
					try {
						s.wait(); //t2就等待了,释放了锁对象,从哪里跌倒从哪里爬起。
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				System.out.println(s.name + "---" + s.age);
				s.flag = false;
				s.notify();//唤醒单个线程
			}
		}
	}

}

class Student {
	String name;
	int age;
	boolean flag = false; // 表示是否有数据
}

同步方法

public class Test {
	public static void main(String[] args) {
		Student s = new Student();

		SetThread st = new SetThread(s);
		GetThread gt = new GetThread(s);

		Thread t1 = new Thread(st);
		Thread t2 = new Thread(gt);
		t1.start();
		t2.start();
	}
}

class SetThread implements Runnable {
	private Student s;
	private int x = 0;

	public SetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			if (x % 2 == 0) {
				s.set("林青霞", 28);
			} else {
				s.set("刘意", 31);
			}
			x++;
		}
	}
}

class GetThread implements Runnable {
	private Student s;
	public GetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			s.get();
		}
	}
}

class Student {
	private String name;
	private int age;
	private boolean flag = false; // 表示是否有数据

	public synchronized void set(String name, int age) {
		if (this.flag) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		this.name = name;
		this.age = age;

		this.flag = true;
		this.notify();
	}

	public synchronized void get() {
		if (!this.flag) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(this.name + "---" + this.age);

		this.flag = false;
		this.notify();
	}
}

4. 线程组

Java中使用ThreadGroup来表示线程组,它可以对一批线程进行分类管理,
Java允许程序直接对线程组进行控制。
默认情况下,所有的线程都属于主线程组。
	public final ThreadGroup getThreadGroup()
我们也可以给线程设置分组
	Thread(ThreadGroup group, Runnable target, String name) 
/*
 * 线程组:Java中使用ThreadGroup来表示线程组,它可以对一批线程进行分类管理,Java允许程序直接对线程组进行控制。
 * 
 * 默认情况下,所有的线程都属于主线程组。
 * public final ThreadGroup getThreadGroup():返回该线程所属的线程组。 
 * public final String getName()			:返回此线程组的名称。  
 * Thread(ThreadGroup group, Runnable target, String name):设置线程组名称
 * public final int getMaxPriority()		:返回此线程组最高优先级
 */
public class Test {
	public static void main(String[] args) {
//		method1();
		method2();
	}

	// 设置线程所属的线程组
	private static void method2() {
		// public ThreadGroup(String name)
		ThreadGroup tg = new ThreadGroup("tg");
		tg.setDaemon(true);

		ThreadGroupRunnable tgr = new ThreadGroupRunnable();
		Thread t1 = new Thread(tg, tgr, "t1");
		Thread t2 = new Thread(tg, tgr, "t2");

		System.out.println(t1.getThreadGroup().getName());
		System.out.println(t2.getThreadGroup().getName()); 
		System.out.println(Thread.currentThread().getThreadGroup().getName());// main

		// 设置t1,t2为守护线程:JVM退出
		t1.setDaemon(true);
		t2.setDaemon(true);

		//tg.stop();
		System.out.println(tg.isDaemon());
		System.out.println(tg.getMaxPriority());
		System.out.println(tg.toString());

		tg.setMaxPriority(8);
		System.out.println(tg.getMaxPriority());
		System.out.println(t1.getPriority());
		System.out.println(t2.getPriority());

		t1.start();
		t2.start();
	}

	// 获取线程所在的线程组名称
	private static void method1() {
		ThreadGroupRunnable tgr = new ThreadGroupRunnable();

		Thread t1 = new Thread(tgr, "t1");
		Thread t2 = new Thread(tgr, "t2");

		// public final ThreadGroup getThreadGroup()
		ThreadGroup tg1 = t1.getThreadGroup();
		ThreadGroup tg2 = t2.getThreadGroup();

		String t1Name = tg1.getName();
		String t2Name = tg2.getName();

		System.out.println(t1Name); // main
		System.out.println(t2Name); // main

		System.out.println(Thread.currentThread().getThreadGroup().getName()); // main

		 t1.start();
		 t2.start();
	}
}

class ThreadGroupRunnable implements Runnable {

	@Override
	public void run() {
		for (int x = 0; x < 10; x++) {
			System.out.println(Thread.currentThread().getName() + ":" + x);
		}
	}
}

5. 线程池

程序启动一个新线程成本是比较高的,因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能,尤其是当程序中要创建大量生存期很短的线程时,更应该考虑使用线程池。
线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。
在JDK5之前,我们必须手动实现自己的线程池,从JDK5开始,Java内置支持线程池

JDK5新增了一个Executors工厂类来产生线程池,有如下几个方法
	public static ExecutorService newCachedThreadPool()
	public static ExecutorService newFixedThreadPool(int nThreads)
	public static ExecutorService newSingleThreadExecutor()
这些方法的返回值是ExecutorService对象,该对象表示一个线程池,可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
	Future submit(Runnable task)
	 Future submit(Callable task)
案例演示
	创建线程池对象
	创建Runnable实例
	提交Runnable实例
	关闭线程池
	
public static ExecutorService newCachedThreadPool()
创建一个具有缓存功能的线程池
缓存:百度浏览过的信息再次访问
public static ExecutorService newFixedThreadPool(int nThreads)
创建一个可重用的,具有固定线程数的线程池
public static ExecutorService newSingleThreadExecutor()
创建一个只有单线程的线程池,相当于上个方法的参数是1		


多线程程序实现方案3
	实现Callable接口
		步骤和线程池执行Runnable对象的差不多。
		但是还可以更好玩一些,求和案例演示
	好处:
		可以有返回值
		可以抛出异常
	弊端:
		代码比较复杂,所以一般不用


匿名内部类方式使用多线程
	new Thread(){代码…}.start();
	New Thread(new Runnable(){代码…}).start();
代码演示:
	new Thread() {
		public void run() {
			for (int x = 0; x < 100; x++) {
				System.out.println(getName() + "---" + x);
			}
		};
	}.start();

	new Thread(new Runnable() {
		@Override
		public void run() {
			for (int x = 0; x < 100; x++) {
				System.out.println(Thread.currentThread().getName() + "---"+ x);
			}
		}
	}).start();

线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
 * 线程池:线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。
 * 
 * 步骤:
 * 		A:定义类MyRunnable实现Runnable接口
 * 		B:创建MyRunnable对象
 * 		C:创建线程池对象
 * 		D:提交
 * 		E:释放
 */
public class Test {
	public static void main(String[] args) {
		MyRunnable my = new MyRunnable();

		// 创建线程池对象
		// public static ExecutorService newFixedThreadPool(int nThreads)
		ExecutorService pool = Executors.newFixedThreadPool(5);

		// 提交代码
		// Future submit(Runnable task)
		pool.submit(my);
		pool.submit(my);
		pool.submit(my);
		pool.submit(my);
		pool.submit(my);

		// 释放
		pool.shutdown();
	}
}

class MyRunnable implements Runnable {

	@Override
	public void run() {
		for (int x = 0; x < 10; x++) {
			System.out.println(Thread.currentThread().getName() + ":" + x);
		}
	}
}

多线程实现方案三:实现 Callable接口

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Callable;

/*
 * 线程池:线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。
 * 
 * 步骤:
 * 		A:定义类MyCallable实现Callable接口
 * 		B:创建MyCallable对象
 * 		C:创建线程池对象
 * 		D:提交
 * 		E:释放
 */
public class Test {
	public static void main(String[] args) {
		MyCallable my = new MyCallable();

		// 创建线程池对象
		// public static ExecutorService newFixedThreadPool(int nThreads)
		ExecutorService pool = Executors.newFixedThreadPool(5);

		// 提交代码
		// Future submit(Runnable task)
		pool.submit(my);
		pool.submit(my);
		pool.submit(my);
		pool.submit(my);
		pool.submit(my);

		// 释放
		pool.shutdown();
	}
}

class MyCallable implements Callable {

	@Override
	public Object call() throws Exception {
		for (int x = 0; x < 10; x++) {
			System.out.println(Thread.currentThread().getName() + ":" + x);
		}
		return null;
	}
}

求和案例:sum = 1+2+3+…+n

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/*
 * 求和案例:sum = 1+2+3+...+n
 */
public class Test {
	public static void main(String[] args) throws InterruptedException,ExecutionException {
		// 创建线程池对象
		ExecutorService pool = Executors.newFixedThreadPool(3);

		// 提交数据
		Future<Integer> f1 = pool.submit(new MyCallable(5));
		Future<Integer> f2 = pool.submit(new MyCallable(10));
		Future<Integer> f3 = pool.submit(new MyCallable(100));

		Integer i1 = f1.get();
		Integer i2 = f2.get();
		Integer i3 = f3.get();

		System.out.println(i1);
		System.out.println(i2);
		System.out.println(i3);

		pool.shutdown();
	}
}

class MyCallable implements Callable<Integer> {

	private int number;

	public MyCallable(int number) {
		this.number = number;
	}

	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for (int x = 1; x <= number; x++) {
			sum += x;
		}
		return sum;
	}
}

匿名内部类的方式开启多线程程序

/*
 * 匿名内部类的方式开启多线程程序。
 * 
 * new 类名() {
 * 		重写方法
 * };
 */
public class Test {
	public static void main(String[] args) {
		/*new Thread() {
			@Override public void run() { 
				for (int x = 0; x < 10; x++) {
					System.out.println("t1:" + x); 
				} 
			} 
		}.start();
		
		new Thread() { 
			@Override public void run() { 
				for (int x = 0; x < 10; x++) {
					System.out.println("t2:" + x); 
				} 
			} 
		}.start();*/
		

		/*new Thread(new Runnable() {
			@Override public void run() { 
				for (int x = 0; x < 10; x++) {
					System.out.println("t3:" + x); 
				} 
			} 
		}).start();
		
		new Thread(new Runnable() {
			@Override public void run() { 
				for (int x = 0; x < 10; x++) {
					System.out.println("t4:" + x); 
				} 
			} 
		}).start();*/
		 

		// 面试
		new Thread(new Runnable() {
			@Override
			public void run() {
				for (int x = 0; x < 10; x++) {
					System.out.println("t5:" + x);
				}
			}
		}) {
			@Override
			public void run() {
				for (int x = 0; x < 10; x++) {
					System.out.println("t6:" + x);
				}
			}
		}.start();
	}
}

6. 定时器

定时器是一个应用十分广泛的线程工具,可用于调度多个定时任务以后台线程的方式执行。在Java中,可以通过Timer和TimerTask类来实现定义调度的功能
Timer
	public Timer()
	public void schedule(TimerTask task, long delay)
	public void schedule(TimerTask task,long delay,long period)
TimerTask
	public abstract void run()
	public boolean cancel()
无论是TimerTask类还是Timer类,其cancel()方法都是为了清除任务队列中的任务。
虽然都是清除任务队列中的任务,却有一些不同:
TimerTask类中的cancel()方法侧重的是将自身从任务队列中清除,其他任务不受影响,
而Timer类中的cancel()方法则是将任务队列中全部的任务清空。
开发中Quartz是一个完全由java编写的开源调度框架。
	1:演示3秒后执行某个动作,
	2:演示3秒后执行某个动作,然后每隔2秒执行某个动作
	3:可以把任务结束掉
import java.util.Timer;
import java.util.TimerTask;

/*
 * 定义任务由两个类来一起完成:
 * Timer,TimerTask
 * 
 * Timer:
 * 		public Timer()创建一个新计时器。
 */
public class Test {
	public static void main(String[] args) {
		// 创建定时器
		final Timer t = new Timer();

		// public void schedule(TimerTask task,long delay):在delay毫秒后完成task的任务
		// t.schedule(new MyTask(t), 3000);

		// 匿名内部类实现
		t.schedule(new TimerTask() {

			@Override
			public void run() {
				System.out.println("炸弹爆炸了,duang");
				t.cancel();//清空队列中全部任务
			}
		}, 3000);
	}
}

class MyTask extends TimerTask {
	private Timer t;

	public MyTask(Timer t) {
		this.t = t;
	}

	@Override
	public void run() {
		System.out.println("炸弹爆炸了");
		t.cancel();
	}
}

连环雷 和 定时雷

/*
 * 炸弹要连续炸
 */
public class Test {
	public static void main(String[] args) throws ParseException {
		Timer t = new Timer();

		// 启动任务
		t.schedule(new TimerTask() {
			@Override
			public void run() {
				System.out.println("要炸了,快跑");
			}
		}, 2000);

		//public void schedule(TimerTask task,long delay,long period):第一次是delay后启动,以后每次是period启动
		t.schedule(new TimerTask() {
			@Override
			public void run() {
				System.out.println("连环雷,炸死你");
			}
		}, 3000, 1000);

		// public void schedule(TimerTask task,Date time):在time时间执行一次
		// public void schedule(TimerTask task,Date time,long period):在time时间开始第一次执行,以后每次period再启动
		String s = "2020-11-5 11:07:00";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date d = sdf.parse(s);

		t.schedule(new TimerTask() {
			@Override
			public void run() {
				System.out.println("炸死你");
			}
		}, d,1000);
	}
}

class MyTask extends TimerTask {
	private Timer t;

	public MyTask(Timer t) {
		this.t = t;
	}

	@Override
	public void run() {
		System.out.println("炸弹爆炸了");
		t.cancel();
	}
}

7. 多线程面试题

多线程面试题
(1)多线程有几种实现方案,分别是哪几种?
(2)同步有几种方式,分别是什么?
(3)启动一个线程是run()还是start()?它们的区别?
(4)sleep()和wait()方法的区别
(5)为什么wait(),notify(),notifyAll()等方法都定义在Object类中
(6)线程的生命周期图

面试题答案

(1)多线程有几种实现方案,分别是哪几种?
答案:3种,但一般说2种常用的

  1. 继承Thread类
  2. 实现Runnable接口
  3. 实现Callable接口,代码复杂,一般不使用
  4. 匿名内部类也可以实现多线程

(2)同步有几种方式,分别是什么?
答案:2种

  1. 同步代码块
  2. 同步方法

(3)启动一个线程是run()还是start()?它们的区别?
答案:启动线程用 start();
区别:
run(): 封装了被线程执行的代码,直接调用仅仅是普通方法的调用
start(): 启动线程,并由JVM自动调用run()方法
注:start()方法被用来启动新创建的线程,而且start()内部调用了run()方法,这和直接调用run()方法的效果不一样。
当你调用run()方法的时候,只会是在原来的线程中调用,没有新的线程启动,start()方法才会启动新线程。

(4)sleep()和wait()方法的区别
答案:
sleep(): 必须指时间; 不释放锁。
wait(): 可以不指定时间,也可以指定时间; 释放锁

(5)为什么wait(),notify(),notifyAll()等方法都定义在Object类中
答案:

  1. 这些方法存在与同步中。
  2. 使用这些方法时必须要标识所属的同步的锁。
  3. 锁可以是任意对象,所以任意对象调用的方法一定定义Object类中。

(6)线程的生命周期图

  1. 新建(new):处于该状态的时间很短暂。已被分配了必须的系统资源,并执行了初始化。表示有资格获得CPU时间。调度器可以把该线程变为runnable或者blocked状态
  2. 就绪(Runnable):这种状态下只要调度器把时间片分配给线程,线程就能运行。处在这种状态就是可运行可不运行的状态
  3. 阻塞(Bolocked):线程能够运行,但有个条件阻止它的运行。当线程处于阻塞状态时,调度器将会忽略线程,不会分配给线程任何CPU时间(例如sleep)。只有重新进入了就绪状态,才有可能执行操作。
  4. 死亡(Dead):处于死亡状态的线程讲不再是可调度的,并且再也不会得到CPU时间。任务死亡的通常方式是从run()方法返回。

一个任务进入阻塞状态,可能有如下原因:

  1. sleep
  2. wait(),知道线程得到了notify()或者notifyAll()消息,线程才会进入就绪状态。
  3. 任务在等待某个输入/输出完成
  4. 线程在试图在某个对象上调用其同步控制方法,但是对象锁不可用,因为另一个任务已经获取了这个锁。

JAVA第十一课:多线程_第5张图片

你可能感兴趣的:(java)