Java基础-多线程学习（下）_new thread(group,run,"t2线程")-优快云博客

本文深入探讨Java多线程的高级应用，包括Runtime类、Timer类的使用，多线程间的通信机制如wait、notify及notifyAll方法的运用，线程组的管理，线程池的工作原理以及Callable接口的实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在前面，我们基本上已经把多线程的基本用法都学完了（点此传送门）

这里，再来深入地学习一点新东西。

Runtime类

首先，这个和多线程没什么关系，今天学到了，就在这里做一下笔记。

每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。可以看出来，这个类使用单例设计。

    public static void main(String[] args) throws IOException {  
        Runtime runtime = Runtime.getRuntime();
//        runtime.exec("shutdown -s -t 300");//300秒后关机
        runtime.exec("shutdown -a");//取消关机
    }

挺好玩的，其实就是相当于在控制台输控制命令。

Timer类

这是一个计时器类。

public void schedule(TimerTask task, Date time)
public void schedule(TimerTask task, Date firstTime, long period)

这是它里面的两个方法，用于制定任务。

TimerTask是什么？查看API发现，他是一个实现了Runnable接口的抽象类（run方法为抽象方法）。那就好办了。

class MyTimerTask extends TimerTask {
	@Override
	public void run() {
		System.out.println("起床啦,起床啦!!!");
	}
}
public class Test {  
    public static void main(String[] args) throws IOException, InterruptedException {  
        Timer timer = new Timer();
        ////第一个参数,是安排的任务,第二个参数是执行的时间,第三个参数是过多长时间再重复执行(毫秒)
        timer.schedule(new MyTimerTask(), new Date(116, 8, 3, 11, 17 , 5),2000);
        
        while(true) {//这里每一秒打印一次时间是为了方便观察上面的结果
        	Thread.sleep(1000);
        	System.out.println(new Date());
        }
    }  
}

可以发现,我制定在5秒的时候启动任务，每两秒重复执行。

多线程的通信

什么时候需要通信

多个线程并发执行时, 在默认情况下CPU是随机切换线程的（同步只能保证同步方法内只有一个线程在跑,但是又不能保证哪个线程在跑）

如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印（A线程执行完执行B线程，B线程执行完执行C线程，C线程执行完执行A线程）

首先，先来了解下几个方法（在Object内）

/*
 * 当调用wait()方法时将，这个线程将释放该对象的独占锁并被放入这个对象的等待队列(这个对象就是锁对象)
 * 需被唤醒后(下面的方法)这样它才能重新获得锁的拥有权和恢复执行。
 * 要确保调用wait()方法的时候拥有锁(要强制当前线程释放对象锁)，即，wait()方法的调用必须放在synchronized方法或synchronized块中。
 */
public final void wait() throws InterruptedException
/*
 * 如果多个线程在等待，它们中的一个将会选择被唤醒。(任意唤醒一个)
 * 被唤醒的线程是不能被直接执行的，需要等到当前线程放弃这个对象的锁。
 * 被唤醒的线程将和其他线程以通常的方式进行竞争，来获得对象的锁。(需和其他线程公平竞争)
 */
public final void notify()
/*
 * 这里和上述方法不同的是,上面方法随机唤醒一个等待线程.
 * 而这里是所有的等待线程都会被唤醒
 */
public final void notifyAll()

/*
 * 上述方法是用在多线程竞争同一锁资源的情况下使用的
 * 谁来调用这些方法？
 * 调用wait()和notify()系列方法时，当前线程必须拥有此对象监视器（即对象锁）(因为必须使用对象锁来调用这些方法)
 * 如果不是使用锁对象来调用(意味该对象没有掌控同步代码的权利),结果会报错(IllegalMonitorStateException)
 * 由于所有的对象都可以成为锁，所以将它放在了Object内
 * 而上面的notify系列的解释有点误差(简单说明),这里的唤醒,只能唤醒此对象监视器(对象锁)上等待的线程
 * 简单的讲:由于多个需同步的代块(或方法)要上锁(而锁只有一把)。所以获得该锁后,该锁能够控制该线程是否需要wait,而它也有权利notify。
 * 总的来说这些方法是以锁为目标的(假设以线程为目标,那么多线程,你又不知道唤醒什么线程,那么估计要错乱了)
 */

1.两个线程间的通信

如何通信（等待唤醒机制）

如果希望线程等待, 就调用wait()

如果希望唤醒等待的线程, 就调用notify()

这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用

class Printer {  
	private int flag = 1;
    public void print1() throws InterruptedException {  
    	synchronized(this) {
    		if(flag != 1) {
    			this.wait();//使自己等待
    		}
            System.out.print("同");  
            System.out.print("志");  
            System.out.print("们");  
            System.out.println("好!");  
            flag = 2;
            this.notify();//用于唤醒 print2
    	}   
    }  
    public void print2() throws InterruptedException { 
    	synchronized(this) {
    		if(flag != 2) {
    			this.wait();//使自己等待
    		}
            System.out.print("首");  
            System.out.print("长");  
            System.out.println("好!");  
            flag = 1;
            this.notify();//用于唤醒 print1
    	}
    }  
}  
public class Test {  
    public static void main(String[] args) throws IOException, InterruptedException {  
        final Printer printer = new Printer();
    	new Thread() {
    		public void run() {
    			while(true) {
    				try {
        				printer.print1();
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}.start();
    	new Thread() {
    		public void run() {
    			while(true) {
    				try {
        				printer.print2();
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}.start();
    }  
}

你会发现其结果同志们好和首长好交替执行了

来模拟下程序的执行：（假设执行 print1的为线程1,print2的为线程2）

1.假设线程1抢到了执行权，进入print1，由于flag = 1 ，所以往下执行打印，将flag = 2，再唤醒（第一次线程2还没执行，所以也没有线程等待）

2.线程1和线程2同时抢执行权，假设还是线程1抢到了执行权，这时flag != 1，所以wait(释放锁,并线程1等待)

3.于是线程2执行了，由于flag = 2,所以往下执行打印，将flag = 1，再唤醒(由于之前的操作,线程1等待了，这里用于唤醒线程1）

4.又开始了互抢执行权，假设线程1抢到了，那么重复第一步操作，要是线程2抢到了，由于flag != 2了，所以自己释放锁并等待，后面会重复第一步操作

2.多个线程间通信

notify()方法是随机唤醒一个线程，notifyAll()方法是唤醒所有线程

由于JDK5之前无法唤醒指定的一个线程，所以如果多个线程之间通信, 需要使用notifyAll()通知所有线程, 用while来反复判断条件

class Printer {  
	private int flag = 1;
    public void print1() throws InterruptedException {  
    	synchronized(this) {
    		while(flag != 1) {
    			this.wait();//使自己等待
    		}
            System.out.print("同");  
            System.out.print("志");  
            System.out.print("们");  
            System.out.println("好!");  
            flag = 2;
            this.notifyAll();//用于唤醒所有该对象锁上等待的线程
    	}   
    }  
    public void print2() throws InterruptedException { 
    	synchronized(this) {
    		while(flag != 2) {
    			this.wait();//使自己等待
    		}
            System.out.print("首");  
            System.out.print("长");  
            System.out.println("好!");  
            flag = 3;
            this.notifyAll();//用于唤醒所有该对象锁上等待的线程
    	}
    }  
    public void print3() throws InterruptedException { 
    	synchronized(this) {
    		while(flag != 3) {
    			this.wait();//使自己等待
    		}
            System.out.print("大");  
            System.out.print("家");  
            System.out.println("好!");  
            flag = 1;
            this.notifyAll();//用于唤醒所有该对象锁上等待的线程
    	}
    }  
}  
public class Test {  
    public static void main(String[] args) throws IOException, InterruptedException {  
        final Printer printer = new Printer();
    	new Thread() {
    		public void run() {
    			while(true) {
    				try {
        				printer.print1();
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}.start();
    	new Thread() {
    		public void run() {
    			while(true) {
    				try {
        				printer.print2();
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}.start();
    	new Thread() {
    		public void run() {
    			while(true) {
    				try {
        				printer.print3();
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}.start();
    }  
}

结果为同志们好！首长好！大家好！交替输出（这里不截图了）

这里我们考虑几种情况，假设以上程序都是使用notify（随机唤醒一个对象），还有假设（print1 为线程1, print2为线程2 ....）

1.在notify的情况下，如果我们还是使用 if 会怎么样？

假设目前线程2和线程3都处于等待状态（说明他们wait()方法那里等待）,线程1跑起来了，打印出语句，设置flag = 2，然后随机唤醒了一个线程（假设3唤醒），这里如果线程3抢到执行权跑起来了，但是它不是从头执行，它是在等待的地方（wait）继续往下执行，好了，现在问题就已经出现了，在print1后直接执行了print3,现在已经不符合规则了。这里的原因因为wait是在if语句里的，使用if相当于在哪里等待就在哪里起来，而不会重新进行判断，所以后面往下执行直接打印了语句

通过上面的分析，那我们用while替代让它继续进行判断（这里还是使用notify为假设），结果会怎么样？

结果应该会更糟糕。和上面的假设一样，线程3被唤醒了，由于使用了while进行了从头判断，发现 2 ！= 3 ，那么又执行了wait()方法，现在自己又处于等待了。现在就剩下线程1了，执行线程1时发现 2！= 1，那么自己执行了wait方法。现在好了，三个同步代码块都处于等待状态，已经没有任何拥有锁对象的活着的线程了，就别提唤醒了。所以你会发现程序不输出了，但却没有停止运行。

综合前面两种情况，所以在多个线程间通信的情况下，我们需使用while和notifyAll

线程间通信注意问题

1,在同步代码块中,用哪个对象锁,就用哪个对象调用wait方法

Q：2,为什么wait方法和notify方法定义在Object这类中?

因为锁对象可以是任意对象,Object是所有的类的基类,所以wait方法和notify方法需要定义在Object这个类中

Q：3,sleep方法和wait方法的区别?

sleep方法必须传入参数,参数就是时间,时间到了自动醒来；wait方法可以传入参数也可以不传入参数,传入参数就是在参数的时间结束后等待,不传入参数就是直接等待

sleep方法在同步函数或同步代码块中,不释放锁（睡着了也抱着锁睡）；wait方法在同步函数或者同步代码块中,释放锁

互斥锁(JDK1.5新特性)

同步

使用ReentrantLock类的lock()和unlock()方法进行同步

通信

使用ReentrantLock类的newCondition()方法可以获取Condition对象

需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法

不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了

class Printer {  
	private ReentrantLock r = new ReentrantLock();
	private Condition c1 = r.newCondition();
	private Condition c2 = r.newCondition();
	private Condition c3 = r.newCondition();
	private int flag = 1;
    public void print1() throws InterruptedException {  
    	//synchronized(this) {
    	r.lock();
    		if(flag != 1) {
    			//this.wait();
    			c1.await();
    		}
            System.out.print("同");  
            System.out.print("志");  
            System.out.print("们");  
            System.out.println("好!");  
            flag = 2;
            //this.notify();
            c2.signal();
        r.unlock();
    	//}   
    }  
    public void print2() throws InterruptedException { 
    	r.lock();
    		if(flag != 2) {
    			c2.await();
    		}
            System.out.print("首");  
            System.out.print("长");  
            System.out.println("好!");  
            flag = 3;
            c3.signal();
    	r.unlock();
    }  
    public void print3() throws InterruptedException { 
    	r.lock();
    		if(flag != 3) {
    			c3.await();
    		}
            System.out.print("大");  
            System.out.print("家");  
            System.out.println("好!");  
            flag = 1;
            c1.signal();
    	r.unlock();
    }  
}

print1我保留了原来的格式可以进行对比。为什么这里可以使用if，因为唤醒是明确的，线程1结束我就唤醒线程2，线程2结束我就唤醒线程3.,如此反复的循环。

线程组

线程组概述

Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。

在默认情况下，所有的线程都属于主线程组。

public final ThreadGroup getThreadGroup() //通过线程对象获取他所属于的组
public final String getName()//通过线程组对象获取组的名字

    public static void main(String[] args)  {  
    	Thread t1 = new Thread() {
    		public void run() {}
    	};
    	Thread t2 = new Thread() {
    		public void run() {}
    	};
    	//获取主线程的线程组名称
    	System.out.println(Thread.currentThread().getThreadGroup().getName());
    	//以下获取t1和t2的线程组名称
    	System.out.println(t1.getThreadGroup().getName());
    	System.out.println(t2.getThreadGroup().getName());
    }  
    /*
     * outPut:
     * main
     * main
     * main
     */

可以看出来默任情况下，所有的线程都属于同一个组，而且都属于main线程组

线程分组

ThreadGroup(String name) 创建线程组对象并给其赋值名字

创建线程对象，在构造函数内传入ThreadGroup

可以设置整组的优先级或者守护线程

    public static void main(String[] args)  { 
    	ThreadGroup tg = new ThreadGroup("我是一个线程组");
    	//构造参数为 ThreadGroup 和 线程名称(String name)
    	Thread t1 = new Thread(tg,"我是线程一") {
    		public void run() {}
    	};
    	Thread t2 = new Thread(tg,"我是线程二") {
    		public void run() {}
    	};
    	//获取主线程的线程组名称
    	System.out.println(Thread.currentThread().getThreadGroup().getName());
    	//以下获取t1和t2的线程组名称
    	System.out.println(t1.getThreadGroup().getName());
    	System.out.println(t2.getThreadGroup().getName());
    	//通过组设置后台线程，表示该组的所有线程都是后台线程
    	tg.setDaemon(true);
    }  
    /*
     * outPut:
     * main
     * 我是一个线程组
     * 我是一个线程组
     */

线程的生命周期

新建,就绪,运行,阻塞,死亡

从图中可以看出来，只有线程到了就绪状态才有资格去抢夺CPU的执行权，我们在之前说过被唤醒的线程是不能被直接执行的，因为他还是需要到就绪状态。stop()方法查看API可得已经过时了（因为过于的暴力,直接stop停止了）。

线程池

线程池概述

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

内置线程池的使用概述

JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法

public static ExecutorService newSingleThreadExecutor() //使用一条线程的线程池
public static ExecutorService newFixedThreadPool(int nThreads)  //设置线程池内的线程数

这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法

//可以提交(执行)Runnable对象或者Callable对象代表的线程
<T> Future<T> submit(Callable<T> task)
Future<?> submit(Runnable task)
void shutdown() //结束线程池

class MyRunnable implements Runnable {
	@Override
	public void run() {
		System.out.println("我要执行了...");
	}
}
public class Test {  
    public static void main(String[] args)  { 
    	ExecutorService pool = Executors.newFixedThreadPool(2);
    	pool.submit(new MyRunnable());
    	pool.submit(new MyRunnable());
    	pool.shutdown();
    }  
}  
/*
 * outPut:
 * 我要执行了...
 * 我要执行了...
 */

当你注释掉 pool.shutdown时，你会发现执行完毕后程序并未停止。因为这个池子会一直等待着你给它任务（给它任务他就会自动运行），除非你手动把它给关了。

如果想深入了解线程池的原理，可以看看这篇转载的这篇原理（点此打开链接），看完后将对线程池的运作有一个更深刻的理解

多线程实现（Callable）

上面有Callable，而且对比发现，submit是一个重载方法，难道Callable和Runnable有什么关系吗?

查看API可发现，Callable 接口类似于 Runnable，里面有一个call方法

V call() throws Exception //计算结果，如果无法计算结果，则抛出一个异常

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 i = 1 ; i <= number ; i++) {
			sum += i;
		}
		return sum;
	}
}
public class Test {  
    public static void main(String[] args) throws InterruptedException, ExecutionException  { 
    	ExecutorService pool = Executors.newFixedThreadPool(2);
    	Future<Integer> f1 = pool.submit(new MyCallable(10));
    	Future<Integer> f2 = pool.submit(new MyCallable(20));
    	// V get() 获取结果
    	System.out.println(f1.get());
    	System.out.println(f2.get());
    	pool.shutdown();
    }  
}  
/*
 * outPut:
 * 55
 * 210
 */

好处：

可以有返回值，可以抛出异常

弊端：

代码比较复杂，所以一般不用

到此，多线程的概念基本上就结束了！