JavaSe——线程

A.线程的概述和多线程的意义

l  多线程概述

•    进程：

•    正在运行的程序，是系统进行资源分配和调用的独立单位。

•    每一个进程都有它自己的内存空间和系统资源。

•    线程：

•    是进程中的单个顺序控制流，是一条执行路径

•    一个进程如果只有一条执行路径，则称为单线程程序。

•    一个进程如果有多条执行路径，则称为多线程程序。

1:要想了解多线程，必须先了解线程，而要想了解线程，必须先了解进程，因为线程是依赖于进程而存在。


2:什么是进程?
通过任务管理器我们就看到了进程的存在。
而通过观察，我们发现只有运行的程序才会出现进程。
进程：就是正在运行的程序。
进程是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。

3:多进程有什么意义呢?
单进程的计算机只能做一件事情，而我们现在的计算机都可以做多件事情。
举例：一边玩游戏(游戏进程)，一边听音乐(音乐进程)。
也就是说现在的计算机都是支持多进程的，可以在一个时间段内执行多个任务。
并且呢，可以提高CPU的使用率。

问题：
一边玩游戏，一边听音乐是同时进行的吗?
不是。因为单CPU在某一个时间点上只能做一件事情。
而我们在玩游戏，或者听音乐的时候，是CPU在做着程序间的高效切换让我们觉得是同时进行的。

4:什么是线程呢?
在同一个进程内又可以执行多个任务，而这每一个任务我就可以看出是一个线程。
线程：是程序的执行单元，执行路径。是程序使用CPU的最基本单位。
单线程：如果程序只有一条执行路径。
多线程：如果程序有多条执行路径。

5:多线程有什么意义呢?
多线程的存在，不是提高程序的执行速度。其实是为了提高应用程序的使用率。
程序的执行其实都是在抢CPU的资源，CPU的执行权。
多个进程是在抢这个资源，而其中的某一个进程如果执行路径比较多，就会有更高的几率抢到CPU的执行权。
我们是不敢保证哪一个线程能够在哪个时刻抢到，所以线程的执行有随机性。

6.并行和并发

并行：逻辑上同时发生，指在某一个时间内同时运行多个程序。

并发：物理上同时发生，指在某一个时间点同时运行多个程序。

B.Java程序运行原理

l  Java程序运行原理

•    java 命令会启动java 虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个“主线程” ，然后主线程去调用某个类的 main 方法。所以main方法运行在主线程中。在此之前的所有程序都是单线程的。

•    思考：

•    jvm虚拟机的启动是单线程的还是多线程的？

多线程。原因是垃圾回收线程也要先启动，否则很容易出现内存溢出。

现在的垃圾回收线程加上前面的主线程，最低启动了两个线程，所以，jvm的启动其实是多线程的。

C.如何实现多线程及多线程方式1的思路

方式1：

step1.写一个MyThread类继承Thread类，

step2.重写MyThread里面的run方法

step3.创建MyThread对象

step4.启动线程

问题：为什么要重写run方法呢？

因为不是类中所有的代码都需要被线程执行的。

而为了区分哪些代码被执行，java提供了Thread类中的run()用来包含那些被线程执行的代码。

package com.core.thread;

public class MyThread extends Thread {
	
	public MyThread() {
		super();
	}
	public MyThread(String name) {
		super(name);
	}

	@Override
	public void run() {
		//耗时操作
		for (int i = 0; i < 10; i++) {
			//获取线程的名称
			System.out.println(getName()+"::"+i);
		}
	}
}

package com.core.thread;

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

		MyThread t2 = new MyThread();
		
		// 设置线程名称
		t2.setName("线程t2");
		Thread t3 = new MyThread("线程t3");
		
		// 获得main函数的线程名称？
		// 返回当前正在执行的线程对象
		Thread currentThread = Thread.currentThread();
		System.out.println("currentThread::" + currentThread.getName());

	}
}

D.线程调度及获取和设置线程优先级

package com.core.thread;

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

		MyThread t2 = new MyThread();
		
		// 设置线程名称
		t2.setName("线程t2");
		Thread t3 = new MyThread("线程t3");
		
		// 获得main函数的线程名称？
		// 返回当前正在执行的线程对象
		Thread currentThread = Thread.currentThread();
		System.out.println("currentThread::" + currentThread.getName());

		// • public final int getPriority()
		// • public final void setPriority(int newPriority)
		System.out.println(t1.getPriority());
		System.out.println(t2.getPriority());
		System.out.println(t3.getPriority());
		t1.setPriority(10);
		t2.setPriority(1);
		t3.setPriority(1);
		
		t1.start();
		t2.start();
		t3.start();
	}
}

E.休眠线程

•    线程休眠

•    public static void sleep(long millis)

package com.core.thread.demo1;

import java.util.Date;

public class SleepThread extends Thread {
	
	public SleepThread() {
		super();
	}
	public SleepThread(String name) {
		super(name);
	}

	@Override
	public void run() {
		//耗时操作
		for (int i = 0; i < 100; i++) {
			//获取线程的名称
			System.out.println(getName()+"--"+i+","+new Date());
			try {
				sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

测试类：

package com.core.thread.demo1;

public class Test {
	public static void main(String[] args) {
		SleepThread st1 = new SleepThread();
		SleepThread st2 = new SleepThread("线程2");
		st1.setName("线程1");

		st1.start();
		st2.start();
	}
}

F.加入线程

•    线程加入

•    public final void join()

等待线程结束

package com.core.thread.demo1;

import java.util.Date;

public class JoinThread extends Thread {
	
	public JoinThread() {
		super();
	}
	public JoinThread(String name) {
		super(name);
	}

	@Override
	public void run() {
		//耗时操作
		for (int i = 0; i < 100; i++) {
			//获取线程的名称
			System.out.println(getName()+"--"+i+","+new Date());
		}
	}
}

测试类：

package com.core.thread.demo1;

public class Test {
	// 线程加入
	// public final void join()

	public static void main(String[] args) {
		JoinThread jt1 = new JoinThread("爸爸");
		JoinThread jt2 = new JoinThread("大儿子");
		JoinThread jt3 = new JoinThread("小儿子");
		jt1.start();
		try {
			jt1.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		jt2.start();
		jt3.start();
	}
}

G.礼让线程

•    线程礼让

•    public static void yield()

package com.core.thread.demo3;

import java.util.Date;

public class YieldThread extends Thread {

	public YieldThread() {
		super();
	}

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

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

测试类：

package com.core.thread.demo3;

public class Test {
	//线程礼让，暂停当前正在执行的线程对象，并执行其他线程
	//让多个线程的执行更协调，但是不能保证一人一次
	public static void main(String[] args) {
		YieldThread st1 = new YieldThread();
		YieldThread st2 = new YieldThread("线程2");
		st1.setName("线程1");

		st1.start();
		st2.start();
	}
}

H.守护线程

public final void setDaemon(boolean on)

将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。

该方法必须在启动线程前调用。 

package com.core.thread.demo4;

import java.util.Date;

public class DaemonThread extends Thread {

	public DaemonThread() {
		super();
	}

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

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

测试类：

package com.core.thread.demo4;

public class Test {
	// public final void setDaemon(boolean on)
	// 将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。
	// 该方法必须在启动线程前调用

	public static void main(String[] args) {
		DaemonThread dt1 = new DaemonThread();
		DaemonThread dt2 = new DaemonThread("关羽");
		dt1.setName("张飞");

		// 设置dt1和dt2为守护线程,必须放在启动线程之前
		dt1.setDaemon(true);
		dt2.setDaemon(true);

		dt1.start();
		dt2.start();
		Thread.currentThread().setName("刘备");
		for (int i = 0; i < 5; i++) {
			System.out.println(Thread.currentThread().getName() + "," + i);
		}
	}
}

I .中断线程

package com.core.thread.demo5;

import java.util.Date;

public class StopThread extends Thread {

	public StopThread() {
		super();
	}

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

	@Override
	public void run() {
		long currentTimeMillis = System.currentTimeMillis();
		Date date = new Date(currentTimeMillis);
		System.out.println("开始时间：" + date);

		try {
			sleep(5000);
		} catch (InterruptedException e) {
			// e.printStackTrace();
			System.out.println("线程被终止");
		}

		currentTimeMillis = System.currentTimeMillis();
		date = new Date(currentTimeMillis);
		System.out.println("结束时间：" + date);
	}
}

测试类：

package com.core.thread.demo5;

public class Test {

	public static void main(String[] args) {
		StopThread st1 = new StopThread("线程1");
		st1.start();
		
		try {
			Thread.currentThread().sleep(3000);
//			st1.stop();
			st1.interrupt();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

注意在终止线程的时候，stop和interrupt的区别。

J.线程生命周期图解

K.多线程方式2的思路及代码实现

l  实现Runnable接口

•    如何获取线程名称

•    如何给线程设置名称

l  实现接口方式的好处

•    可以避免由于Java单继承带来的局限性。

•    适合多个相同程序的代码去处理同一个资源的情况，把线程同程序的代码，数据有效分离，较好的体现了面向对象的设计思想。

package com.core.thread.demo6;

public class MyRunnable implements Runnable {

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

}

测试类：

package com.core.thread.demo6;

public class Test {
	// 多线程的方式2
	// a.写一个MyRunnable类继承Runnable接口
	// b.重写run()方法
	// c.创建MyRunnable对象
	// d.创建Thread对象，并把c步骤创建的MyRunnable对象作为构造参数传递
	public static void main(String[] args) {
		MyRunnable runnable = new MyRunnable();
		Thread t1 = new Thread(runnable, "线程1");
		Thread t2 = new Thread(runnable, "线程2");
		t1.start();
		t2.start();
	}
}

L.多线程两种方式的图解比较及区别

M.线程安全

如，某电影院目前正在上映贺岁大片，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票。

用多线程来实现，两种方法。

第一种，继承Thread类，重写run方法。

第二种，实现Runnable接口。

先用第一种方法：

package com.core.thread.demo7;

public class SellTicket extends Thread {
	public static int ticketNum = 100;
	public SellTicket(String name){
		super(name);
	}
	@Override
	public void run() {
//		while(ticketNum>0){
//			
//		}
		while(true){
			if(ticketNum >0){
				System.out.println(Thread.currentThread().getName()+"正在出售"+ticketNum+"张票");
				ticketNum--;
			}
		}
	}
}

测试类：

package com.core.thread.demo7;

//某电影院目前正在上映贺岁大片，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票
public class Test {
	public static void main(String[] args) {
		SellTicket st1 = new SellTicket("窗口1");
		SellTicket st2 = new SellTicket("窗口2");
		st1.start();
		st2.start();
	}
}

通过打印可以看出，这个是存在线程安全的！暂时先放一下，稍后解决。

接下来，使用实现Runnable接口的方式。

package com.core.thread.demo8;

public class SellTicket implements Runnable {
private static int ticketNum = 100;
	@Override
	public void run() {
		while(true){
			if(ticketNum >0){
				try {
					Thread.currentThread().sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"正在出售"+ticketNum+"张票");
				ticketNum--;
			}
		}
	}

}

package com.core.thread.demo8;

//某电影院目前正在上映贺岁大片，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票
//实现Runnable接口
public class Test {
	public static void main(String[] args) {
		SellTicket st = new SellTicket();
		Thread t1 = new Thread(st, "窗口1");
		Thread t2 = new Thread(st, "窗口2");
		t1.start();
		t2.start();
	}

}

注意：为了演示方便，我在售票的时候，睡眠了一段时间。从打印的数据来看，还是存在线程安全的问题。

N.出现了同票和负数票的原因分析

l  问题

•    相同的票出现多次

•    CPU的一次操作必须是原子性的

•    还出现了负数的票

•    随机性和延迟导致的

l  注意

•    线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。

O.线程安全问题的产生原因分析

l  首先想为什么出现问题?(也是我们判断是否有问题的标准)

•    是否是多线程环境

•    是否有共享数据

•    是否有多条语句操作共享数据

l  如何解决多线程安全问题呢?

•    基本思想：让程序没有安全问题的环境。

•    怎么实现呢?

•    把多个语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可。

P.使用同步代码块解决线程安全问题

package com.core.thread.demo8;

public class SellTicket implements Runnable {
	private static int ticketNum = 100;
	//创建锁对象
	private Object obj = new Object();

	@Override
	public void run() {
		while (true) {
			synchronized (obj) {
				if (ticketNum > 0) {
					try {
						Thread.currentThread().sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + "正在出售"
							+ ticketNum + "张票");
					ticketNum--;
				}
			}
		}
	}

}

package com.core.thread.demo8;

//某电影院目前正在上映贺岁大片，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票
//实现Runnable接口
public class Test {
	public static void main(String[] args) {
		SellTicket st = new SellTicket();
		Thread t1 = new Thread(st, "窗口1");
		Thread t2 = new Thread(st, "窗口2");
		Thread t3 = new Thread(st, "窗口3");
		t1.start();
		t2.start();
		t3.start();
	}

}

Q.同步代码块的特点和优缺点

l  同步的前提

•    多个线程

•    多个线程使用的是同一个锁对象

l  同步的好处

•    同步的出现解决了多线程的安全问题。

l  同步的弊端

•    当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

R.同步方法

package com.core.thread.demo10;

public class SellTicket implements Runnable {
private static int ticketNum = 100;
	@Override
	public void run() {
		while(true){
			sellTicket();
		}
	}
	private synchronized void sellTicket() {
		if(ticketNum >0){
			try {
				Thread.currentThread().sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"正在出售"+ticketNum+"张票");
			ticketNum--;
		}
	}

}

S.关于使用同步方法锁的问题

回顾一下，关于我们使用的锁！

package com.core.thread.demo11;

public class SellTicket implements Runnable {
	private static int ticketNum = 100;
	private Object obj = new Object();
	private Test t = new Test();

	@Override
	public void run() {
		while (true) {
			// 使用Object类为锁
/*			synchronized (obj) {
				if (ticketNum > 0) {
					try {
						Thread.currentThread().sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()
							+ "正在出售" + ticketNum + "张票");
					ticketNum--;
				}
			}

			// 使用任意类为锁
			synchronized (t) {
				if (ticketNum > 0) {
					try {
						Thread.currentThread().sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()
							+ "正在出售" + ticketNum + "张票");
					ticketNum--;
				}
			}
*/
			// 使用字节码类为锁
			synchronized (SellTicket.this) {
				if (ticketNum > 0) {
					try {
						Thread.currentThread().sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()
							+ "正在出售" + ticketNum + "张票");
					ticketNum--;
				}
			}
		}
	}

	private synchronized void sellTicket() {
		if (ticketNum > 0) {
			try {
				Thread.currentThread().sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "正在出售"
					+ ticketNum + "张票");
			ticketNum--;
		}
	}

}

再回过来，看同步方法到底是使用哪一个锁呢？

package com.core.thread.demo12;

public class SellTicket implements Runnable {
	private static int ticketNum = 100;
	private Object obj = new Object();
	private Test t = new Test();
	private int x = 1;

	@Override
	public void run() {
		while (true) {
			if (x % 2 == 1) {
				synchronized (this) {
					// 这里注意了，如果是SellTicke.class 设为锁，则会出现售0票的现象。
					// 但是如果要是this，或者SellTicket.this 设为锁，则售票正常[可以看下面的例子，sellTicket为静态方法]
					if (ticketNum > 0) {
						try {
							Thread.currentThread().sleep(100);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName()
								+ "正在出售" + ticketNum + "张票");
						ticketNum--;
					}
				}
			} else {
				sellTicket();
			}
			x++;
		}
	}

	private synchronized void sellTicket() {
		if (ticketNum > 0) {
			try {
				Thread.currentThread().sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "正在出售"
					+ ticketNum + "张票");
			ticketNum--;
		}
	}

}

静态方法发锁：

package com.core.thread.demo12;

//某电影院目前正在上映贺岁大片，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票
//实现Runnable接口
public class Test {
//	小结：
//	A：同步代码块上的锁对象是谁？
//		任意对象。
//	B:同步方法是锁是谁？
//		this
//	C:静态方法的锁对象是谁？
//		类的字节码文件
	
	public static void main(String[] args) {
		SellTicket st = new SellTicket();
		Thread t1 = new Thread(st, "窗口1");
		Thread t2 = new Thread(st, "窗口2");
		Thread t3 = new Thread(st, "窗口3");
		t1.start();
		t2.start();
		t3.start();
	}

}

小结：

A：同步代码块上的锁对象是谁？
任意对象。
B:同步方法是锁是谁？
this
C:静态方法的锁对象是谁？
类的字节码文件对象

T.回顾以前的线程安全的类

package com.core.thread.demo13;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Hashtable;
import java.util.List;
import java.util.Vector;

public class Test {

	public static void main(String[] args) {
		// 回顾以前讲过的线程安全的类
		StringBuffer sb = new StringBuffer();
		Vector<Object> vector = new Vector<>();
		Hashtable<Object, Object> hashtable = new Hashtable<>();

		ArrayList<Object> list = new ArrayList<>();// 线程不安全。
		// Collections类中给我提供一个方法
		// synchronizedList
		// public static <T> List<T> synchronizedList(List<T> list)
		// 返回指定列表支持的同步（线程安全的）列表。为了保证按顺序访问，必须通过返回的列表完成所有对底层实现列表的访问。
		List<Object> list2 = Collections.synchronizedList(list);//线程安全。
	}

}