JavaSE之多线程

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_1018944104/article/details/82888669

一、线程与进程

• 进程：内存中正在运行的一个应用程序。
• 线程：进程中的一个执行流程。
• 多线程：进程中有两个或以上的线程在轮询的执行。轮询的速度特别快，人感觉不到，所以多个线程就像并行执行一样。

二、线程的状态

1.线程的5种状态

• New（新建）
• Runnable（就绪）
• Running（运行）
• Blocked（阻塞）
• Dead（死亡）

2.线程状态图解

3.线程生命周期

• 新建：创建了一个线程对象，比如 Thread thread = new Thread();
• 就绪：等待CPU调用执行，比如 thread.start();
• 运行：CPU调用了处于就绪状态的一个线程，即执行了run();方法。
• 阻塞：处于运行状态的线程，由于某种原因暂停了CPU的调用执行。
  • sleep() 和 join()阻塞：
    • 线程A调用sleep()方法，则线程A处于阻塞状态，等待超时才能恢复到就绪状态。
    • 线程A调用线程B的join()方法，则线程A等待线程B执行完毕再恢复到就绪状态。
  • 同步阻塞
  • wait() 阻塞
• 死亡：线程正常结束或异常退出。

三、创建线程的方式

1.主线程

• 当Java程序启动时执行。
• 主线程是产生其他子线程的线程。
• 主线程的任务就是主方法。
• 启动一个Java程序至少需要启动几个线程？两个，主线程和自动垃圾回收线程。

2.创建线程的两种方式：继承Thread和实现Runnable

2.1.继承Thread

示例：

class MyThread extends Thread{
	MyThread(){}
	MyThread(String name){
		super(name);
	}
	@Override
	public void run() {
		for (int i = 0; i < 4; i++) {
			System.out.println(Thread.currentThread());
		}
	}
}
public class TestThread {
	public static void main(String[] args) {
		//创建了一个子线程
		MyThread t = new MyThread("线程一");
		//启动线程
		t.start();
		//运行时异常IllegalThreadStateException，start()方法只能调用异常，也就是子线程只能启动一次
//		t.start();
		//不能这样启动子线程。因为线程是main，这是主线程里面的任务，跟子线程没有关系
//		t.run();
	}
}

2.2.实现Runnable

示例：

class ThreadDemo implements Runnable{
	@Override
	public void run() {
		for (int i = 0; i < 3; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}
}
public class TestThread2 {
	public static void main(String[] args) {
		//注意：这不是一个线程对象
		ThreadDemo demo = new ThreadDemo();
		//可以给线程起名
		Thread t =new Thread(demo,"张三");
		//启动线程时，就能调用demo对象中的run()方法了。
		t.start();
	}
}

2.3.两种创建方式的区别

• 继承Thread类后就是线程类，而实现Runnable接口不是线程类；
• 继承Thread类的所有功能，实现接口只有run()方法；
• 实现接口利于资源共享。

四、线程的优先级

1.什么是线程的优先级？有什么用处？取值范围是什么？

• 理论上，优先级高的线程比优先级低的线程获得更多的CPU时间，相等优先级的线程有同等的权利使用CPU。
• 实际上，线程获得CPU的时间通常由包括优先级在内的多个因素决定。
• 线程优先级从低到高的范围是1-10。

2.如何设置和查看线程的优先级？

示例：

class SubThread2 implements Runnable{
	@Override
	public void run() {
		for (int i = 0; i < 3; i++) {
			System.out.println(Thread.currentThread().getName() + ":玩儿游戏");
		}
	}
}
public class TestSubThread2 {
	public static void main(String[] args) {
		SubThread2 th = new SubThread2();
		Thread zhangsan = new Thread(th,"zhangsan");
		Thread lisi = new Thread(th,"lisi");
//		zhangsan.setPriority(1);
//		lisi.setPriority(10);
		zhangsan.setPriority(Thread.MAX_PRIORITY);
		lisi.setPriority(Thread.MIN_PRIORITY);
		zhangsan.start();
		lisi.start();
		System.out.println(zhangsan.getPriority());
		System.out.println(lisi.getPriority());
	}
}

五、线程相关方法

常见方法：

• sleep()：阻塞线程，参数是long类型，表示当前线程被阻塞的毫秒数。在当前线程中执行Thread.sleep(2000);代码即可。
• join()：线程A调用线程B的join()方法，则线程A等待线程B执行完毕再恢复到就绪状态。
• wait()：放弃CPU时间，放弃锁，进入阻塞状态。调用方式：在当前线程中直接执行 waite()即可。可以带参或不带参。
• notify()/notifyAll()：唤醒通过waite()阻塞的线程，进入同步阻塞状态。调用方式：在当前线程中直接执行notify()即可。
• interrupt()：线程A中调用线程B的interrupt()方法，那中么线程B被断进入到异常处理流程，但前提是线程B必须处于sleep或join状态，否则不会引发这个异常。
• yield()：线程让步，让同等优先级或高优先级的线程获取CPU时间。在当前线程中执行Thread.yield();代码即可。

sleep() 与 wait() 的区别：

• sleep() 必须指定参数，wait()参数是可选的；
• sleep()放弃了CPU的时间但不放弃锁，wait()放弃了CPU的时间也放弃了锁。

示例：

class MyThread3 implements Runnable{
	private int i = 10;
	@Override
	public void run() {
		synchronized(this){
			String threadName = Thread.currentThread().getName();
			for (; i >= 0; i-- ){
				if (i == 5 && threadName.equals("t1")) {
					try {
//						Thread.sleep(1000);
						wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				System.out.println(threadName + ":" + i);
				if (i == 0) {
					System.out.println("我醒了");
					notify();
				}
			}
		}
	}
}
public class TestSleepAndWait {
	public static void main(String[] args) {
		MyThread3 th = new MyThread3();
		Thread t1 = new Thread(th, "t1");
		Thread t2 = new Thread(th, "t2");
		t1.start();
		t2.start();
	}
}

六、线程的同步

1.什么是线程同步？

• 当两个或两个以上的线程需要共享资源，它们需要某种方法来确定资源在某一刻仅被一个线程占用。达到此目的的过程叫做同步（synchronized）
• 在资源共享的情况下，线程A访问某对象的同步资源获得同步锁，那么其他线程就不能再访问此对象的同步同步资源了，但是可以访问其他对象的资源方法，或者访问此对象的非同步资源。
• 当一个线程需要锁定，它必须进入管程。管程是使用资源独占的一种权利

2.为什么使用同步？

保证对共享资源的读写一致性。

3.如何使用线程同步？

3.1.synchronized关键词

语法：

• 同步方法：synchronized 方法名(){ }
• 同步代码块：synchronized(对象){ //同步块 }
• 以上二者方式锁的都是对象。

获得锁和释放锁的标志：（没有明确的获得锁或释放锁的标志，但是可以推断出下面这些情况！）

• 获得锁：当线程执行同步代码块或同步方法中的代码时，需要获得对象锁。
• 释放锁：
  • 同步代码块或同步方法中的代码执行完毕；
  • return，break结束了方法；
  • 同步代码块或同步方法中出现了没有处理的异常；
  • 线程执行了wait()方法。

示例：同一银行账户存钱

class Bank implements Runnable{
	private int money;
	//同步方法
	/*private synchronized void setMoney(){
		this.money += 100;
		System.out.println(Thread.currentThread().getName() + "存了100元，余额" + this.money + "元");
	}*/
	private void setMoney(){
		this.money += 100;
		System.out.println(Thread.currentThread().getName() + "存了100元，余额" + this.money + "元");
	}
	@Override
	public void run() {
		for (int i = 0; i < 3; i++) {
			//同步代码块
			synchronized(this){
				setMoney();
			}
		}
	}
}
public class TestBank {
	public static void main(String[] args) {
		Bank bank = new Bank();
		Thread zhangsan = new Thread(bank,"张三");
		Thread lisi = new Thread(bank,"李四");
		zhangsan.start();
		lisi.start();
	}
}

3.2.ReentrantLock锁（公平锁）

语法：

try{
    //加锁lock()
}finally{
    //释放锁unlock()
}

优势：

• 可以显示的加锁和释放锁。
• 是一种公平锁，CPU会把锁让给等待时间最长的那个线程。

示例：多线程实现5个小朋友报数，每间隔一秒报数一次。

import java.util.concurrent.locks.ReentrantLock;
class Person implements Runnable{
	private int num = 1;
	//创建公平锁对象
	private ReentrantLock lock = new ReentrantLock();
	private void askNum(String name){
		try {
			//启动锁功能
			lock.lock();
			System.out.println(name + "\t" + num++);
		} finally {
			//finally保证一定释放锁
			lock.unlock();
		}
	}
	@Override
	public void run() {
		askNum(Thread.currentThread().getName());
	}
}
public class TestAskNum {
	public static void main(String[] args) {
		Person p = new Person();
		Thread t1 = new Thread(p, "郭靖");
		Thread t2 = new Thread(p, "杨康");
		Thread t3 = new Thread(p, "欧阳克");
		Thread t4 = new Thread(p, "周伯通");
		Thread t5 = new Thread(p, "黄蓉");
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		t5.start();
	}
}

4.线程同步的特点

• 每个对象只有一个锁（lock）与之关联。
• 实现同步要很大的系统开销作为代价，甚至可能造成死锁，所以要尽量避免无谓的同步控制。

七、线程死锁

1.什么是死锁？

多个线程进入到了循环等待的状态，就造成了死锁。

2.死锁的特点？

• 死锁是很难调试的错误，只有两个线程的时间段刚好符合时才能发生。
• 我们在编写多线程并含有同步方法调用的程序中要格外小心，避免死锁发生。

3.如何写一个死锁？

示例：两个线程相互拿着对方需要的锁，你不给我，我就没法释放你需要的锁。

class ZS{
	public void say(){
		System.out.println("张三：你给我书，我就给你画");
	}
	public void get(){
		System.out.println("张三获得了书");
	}
}
class LS{
	public void say(){
		System.out.println("李四：你给我画，我就给你书");
	}
	public void get(){
		System.out.println("李四获得了画");
	}
}
class MyThread2 extends Thread{
	static ZS zhangsan = new ZS();
	static LS lisi = new LS();
	boolean tag = false;
	@Override
	public void run() {
		if(tag == true){
			//相互拿着对方需要的锁，你不给我，我就没法释放你需要的锁
			synchronized(zhangsan){
				zhangsan.say();
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				synchronized (lisi) {
					zhangsan.get();
				}
			}
		} else {
			//相互拿着对方需要的锁，你不给我，我就没法释放你需要的锁
			synchronized(lisi){
				lisi.say();
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				synchronized(zhangsan){
					lisi.get();
				}
			}
		}
	}
	
}
public class TestLock {
	public static void main(String[] args) {
		MyThread2 zhangsan = new MyThread2();
		zhangsan.tag = true;
		MyThread2 lisi = new MyThread2();
		zhangsan.start();
		lisi.start();
	}
}

八、线程协作操作

1.多线程

示例：

class SubThread1 implements Runnable{
	@Override
	public void run() {
		for (int i = 0; i < 3; i++) {
			System.out.println(Thread.currentThread().getName() + ":玩儿游戏");
		}
	}
}
public class TestSubThread1 {
	public static void main(String[] args) throws InterruptedException {
		//注意：这不是一个线程对象
		SubThread1 sub1 = new SubThread1();
		//创建线程对象
		Thread zhangsan = new Thread(sub1, "张三");
		Thread lisi = new Thread(sub1, "李四");
		zhangsan.start();
		lisi.start();
		//毫秒 等待足够长的时间
//		Thread.sleep(1000);
		//线程是否运行，是true
		/*if (zhangsan.isAlive() || lisi.isAlive()) {
			Thread.sleep(10);
		}*/
		//join() 让调用该方法的线程先执行，执行完了主线程再进入就绪状态。
		zhangsan.join();
		lisi.join();
		System.out.println("程序结束！");
	}
}

2.生产与销售模式

示例：实现生产包子和销售包子

class QingFeng {
	private int count;
	private boolean tag = false;
	synchronized public void put(int count){
		//true
		if (tag == true) {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.count  = count;
		System.out.println("生产:" + this.count);
		tag = true;
		notify();
	}
	
	synchronized public void get(){
		//没有包子
		if (tag == false) {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("消费：" + this.count);
		tag = false;
		notify();
	}
}
//生产
class Productor implements Runnable{
	private QingFeng qingfeng;
	public Productor(){}
	public Productor(QingFeng qingfeng){this.qingfeng = qingfeng;}
	@Override
	public void run() {
		for (int i = 1; i <= 5; i++) {
			qingfeng.put(i);
		}
	}
}
//销售
class Customer implements Runnable{
	private QingFeng qingfeng;
	public Customer(){}
	public Customer(QingFeng qingfeng){this.qingfeng = qingfeng;}
	@Override
	public void run() {
		for (int i = 1; i <= 5; i++) {
			qingfeng.get();
		}
	}
}
public class TestQingFeng {
	public static void main(String[] args) {
		QingFeng qf = new QingFeng();
		Productor p = new Productor(qf);
		Customer c = new Customer(qf);
		Thread t1 = new Thread(p);
		Thread t2 = new Thread(c);
		t1.start();
		t2.start();
	}
}