Java-多线程
一、基本概念
程序（program）：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程（process)：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程，有生命周期：自身的产生、存在和消亡的过程。程序是静态的，而进程是动态的。
线程（thread）：进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多个线程，就是支持多线程的。线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（PC），线程切换的开销小。
二、线程的创建和使用（四种方式）
1.前提概念
-
Java的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现。
-
Thread类的特性：
- 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体 - 通过该Thread对象的start()方法来启动这个线程，而非直接调用run() -
Thread类的构造器：
- Thread()：创建新的Thread对象 - Thread（String threadname)：创建线程并指定线程实例名 - Thread（Runnable target）：指定创建线程的目标对象，它实现了Runnable接口中的run方法 - Thread（Runnable target，String name)：创建新的Thread对象 -
Thread类的有关方法：
- void start()：启动线程，并执行对象的run()方法 - run()：线程在被调度时执行的操作 - String getName()：返回线程的名称 - void setName(String name)：设置该线程名称 - static Thread currentThread()：返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类 - static void yield()：线程让步。暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程 - join()：当某个程序执行流中调用其他线程的join方法时，调用线程将被阻塞，直到join()方法加入的join线程执行完为止 - static void sleep(long millis)：令当前活动线程在指定时间段内放弃对CPU控制，使其他线程有机会被执行，时间到后重排队 - stop()：强制线程生命期结束，不推荐使用 - boolean isAlive()：返回boolean，判断线程是否还活着
2.创建线程
方式一：继承Thread类
使用步骤：
1. 定义子类继承Thread类
2. 子类中重写Thread类中的run方法
3. 创建Thread子类对象，即创建了线程对象
4. 调用线程对象start方法：启动线程，调用run方法
注意：
1.不能手动调用run()方法,想要启动多线程，必须调用start()方法
2.run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定
3.一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出异常“IllegalThreadStateException”
示例：
//1. 定义子类继承Thread类
class MyThread extends Thread{
//2. 子类中重写Thread类中的run方法
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("子进程：" + i);
}
}
}
public class ThreadTest1 {
public static void main(String[] args) {
//3. 创建Thread子类对象，即创建了线程对象
MyThread mt = new MyThread();
//4. 调用线程对象start方法：启动线程，调用run方法
mt.start();
}
}
方式二：实现Runnable接口
使用步骤：
1. 定义子类,实现Runnable接口
2. 子类中重写Runnable接口中的run方法
3. 创建实现类的对象
4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中
5. 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法
示例：
//1. 定义子类,实现Runnable接口
class MyThread2 implements Runnable{
//2. 子类中重写Runnable接口中的run方法
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0){
System.out.println(i);
}
}
}
}
public class ThreadTest2 {
public static void main(String[] args) {
//3. 创建实现类的对象
MyThread2 myThread2 = new MyThread2();
//4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中
Thread T1 = new Thread(myThread2);
//调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法
T1.start();
}
}
实现Runnable接口创建线程的好处：
1.避免了单继承的局限性
2.多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源
方式三：实现Callable接口
1.相较于Runnable相比，Callable功能更强大些
- 相比run()方法，可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助FutureTask类，比如获取返回结果
Future接口：
- 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等
- FutureTask是Future接口的唯一的实现类
- FutureTask同时实现了Runnable,Future接口。它即可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值
使用步骤：
1.创建一个实现Callable的实现类
2.实现call方法，将此线程需要执行的操作声明在call()中
3.创建Callable接口实现类的对象
4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
5.将FutureTask的对象作为参数传递到Thread类构造器中，创建Thread对象，并调用start()方法
6.可以选择获取Callable中的call方法的返回值
示例：
//1.创建一个实现Callable的实现类
class MyThread3 implements Callable{
//2.实现call方法，将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i < 100; i++) {
if (i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadTest3 {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
MyThread3 numThread = new MyThread3();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类构造器中，创建Thread对象，并调用start()方法
new Thread(futureTask).start();
try {
//6.可以选择获取Callable中的call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值,该方法可选
Object sum = futureTask.get();
System.out.println(sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
方式四：使用线程池
由于线程的创建和销毁、使用量特别大的资源。所以为了避免资源的浪费，可以提前创建多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。
线程池相关API：
- JDK5.0起提供了线程池相关API：ExecutorService和Executors
- ExecutorService：真正的线程池接口。常见的子类ThreadPoolExecutor
- void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
- Future submit(Callable task)：执行任务，有返回值，一般又来执行Callable
- void shutdown()：关闭连接池
-Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
- Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
- Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
- Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
- Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行
示例：
class MyThread4 implements Runnable{
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if (i % 2 == 0){
System.out.println(i);
}
}
}
}
public class ThreadTest4 {
public static void main(String[] args) {
//1.提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
/*//可以选择设置一些线程池的属性
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
service1.setCorePoolSize(10);*/
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new MyThread4());//适合用于Runnable
// service.submit(Callable callable);//适合用于Callable，可以使用futureTask接收返回值
//3.关闭连接池
service.shutdown();
}
}
三、线程的同步
多个线程执行的不确定性会引起执行结果的不稳定，Java对于多线程的安全问题提供了专业的解决方式：同步机制
同步机制的方式一：synchronized关键字
1. 同步代码块：
synchronized (同步监视器){
// 需要被同步的代码；
}
- 同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。但必须保证其唯一性。
2. synchronized还可以放在方法声明中，表示整个方法为同步方法。
例如： public synchronized void show (String name){
….
}
示例一：实现Runnable接口的线程同步—>同步代码块
class Windows1 implements Runnable{
private int tickey = 100;
Object object = new Object();
@Override
public void run() {
while (true){
//object就是同步监视器,或者使用this
synchronized (object){
//synchronized (this){
if (tickey > 0){
System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + tickey);
tickey--;
}else{
break;
}
}
}
}
}
public class WindowTest1 {
public static void main(String[] args) {
Windows1 w = new Windows1();
Thread T1 = new Thread(w);
Thread T2 = new Thread(w);
Thread T3 = new Thread(w);
T1.setName("窗口1");
T2.setName("窗口2");
T3.setName("窗口3");
T1.start();
T2.start();
T3.start();
}
}
示例二：继承Thread类方法的线程同步—>同步代码块
class Windows extends Thread{
private static int tickey = 100;
static Object object = new Object();
@Override
public void run() {
while (true){
//synchronized (object){
//注意此时利用this当前对象就是错误的--->synchronized (this){
//因为通过继承的方式创建的对象不唯一了，这时可以考虑将当前类作为对象--->反射
synchronized(Windows.class){
if (tickey > 0){
System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + tickey);
tickey--;
}else{
break;
}
}
}
}
}
public class WindowTest {
public static void main(String[] args) {
Windows T1 = new Windows();
Windows T2 = new Windows();
Windows T3 = new Windows();
T1.setName("窗口1");
T2.setName("窗口2");
T3.setName("窗口3");
T1.start();
T2.start();
T3.start();
}
}
同步代码块的用法：
- 在实现Runnable接口中创建多线程方式中，可以考虑使用this充当同步监视器
- 在继承Thread类创建多线程的方式中，慎用this充当同步监视器，可以考虑当前类充当
示例三：实现Runnable接口的线程同步—>同步方法
class Windows3 implements Runnable{
private int tickey = 100;
@Override
public void run() {
while (true){
if (tickey > 0){
show();
}else{
break;
}
}
}
private synchronized void show(){
//此时的同步监视器为this
if (tickey > 0){
System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + tickey);
tickey--;
}
}
}
public class WindowTest3 {
public static void main(String[] args) {
Windows3 w = new Windows3();
Thread T1 = new Thread(w);
Thread T2 = new Thread(w);
Thread T3 = new Thread(w);
T1.setName("窗口1");
T2.setName("窗口2");
T3.setName("窗口3");
T1.start();
T2.start();
T3.start();
}
}
示例四：继承Thread类方法的线程同步—>同步方法
class Window4 extends Thread{
private static int tickey = 100;
@Override
public void run() {
while (true){
if (tickey > 0){
show();
}else{
break;
}
}
}
//private synchronized void show(){//此时的同步监视器为T1,T2,T3.显然是错误的，因为不唯一
//因此要将方法声明为静态的
private static synchronized void show(){
//此时的同步监视器为 Window4.class
if (tickey > 0){
System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + tickey);
tickey--;
}
}
}
public class WindowTest4 {
public static void main(String[] args) {
Window4 T1 = new Window4();
Window4 T2 = new Window4();
Window4 T3 = new Window4();
T1.setName("窗口1");
T2.setName("窗口2");
T3.setName("窗口3");
T1.start();
T2.start();
T3.start();
}
}
同步方法用法：
1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明
2.非静态的同步方法，同步监视器是：this
静态的同步方法，同步监视器是：当前类本身
同步机制的方式二：Lock（锁）
从JDK5.0开始，Java提供了更强大的线程同步机制—通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
- ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
示例：
class Window5 implements Runnable{
private int tickey = 100;
//1.实例化ReentrantLock
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true){
try {
//2.调用lock()
lock.lock();
if (tickey > 0){
System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + tickey);
tickey--;
}else{
break;
}
}finally {
//3.解锁
lock.unlock();
}
}
}
}
public class LockTest {
public static void main(String[] args) {
Windows1 w = new Windows1();
Thread T1 = new Thread(w);
Thread T2 = new Thread(w);
Thread T3 = new Thread(w);
T1.setName("窗口1");
T2.setName("窗口2");
T3.setName("窗口3");
T1.start();
T2.start();
T3.start();
}
}
四、线程的通信
涉及到的三个方法：
- wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
- notify()：一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的
- notifyAll()：一旦执行此方法，就会唤醒所有被wait的线程
注意：
- 这三个方法必须适用在同步代码块和同步方法中
- 三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则会出现IllegalMonitorStateException异常
- 三个方法是定义在java.lang.Object类中
示例：
class Number1 implements Runnable{
private int number = 1;
//使线程交替打印
@Override
public void run() {
while (true){
synchronized (this){
notify();
if(number <= 100){
System.out.println(Thread.currentThread().getName() + ":" + number);
number++;
try {
//使得调用如下wait()方法的线程进入阻塞状态
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
break;
}
}
}
}
}
public class CommunicationTest {
public static void main(String[] args) {
Number1 number1 = new Number1();
Thread t1 = new Thread(number1);
Thread t2 = new Thread(number1);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
五、线程的生命周期
六、生产者-消费者问题
class Clerk{
private int productNum = 0;
//生产产品
public synchronized void produceProduct() {
if (productNum < 20){
productNum++;
System.out.println(Thread.currentThread().getName() + ":开始生产第" + productNum);
notify();
}else{
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//消费产品
public synchronized void consumerProduct() {
if (productNum > 0){
System.out.println(Thread.currentThread().getName() + "开始消费第" + productNum);
productNum--;
notify();
}else{
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Producer extends Thread{
private Clerk clerk;
public Producer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(getName()+"开始生产产品");
while (true){
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.produceProduct();
}
}
}
class Consumer extends Thread{
private Clerk clerk;
public Consumer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(getName()+"开始消费产品");
while (true){
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.consumerProduct();
}
}
}
public class ProductTest {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Producer p1 = new Producer(clerk);
p1.setName("生产者1");
Consumer c1 = new Consumer(clerk);
c1.setName("消费者1");
Consumer c2 = new Consumer(clerk);
c1.setName("消费者1");
p1.start();
c1.start();
c2.start();
}
}
-----总结于尚硅谷-宋红康教学视频