java基础---线程的停止

本文介绍了两种在Java中停止线程的方法:一是使用退出标志控制循环条件,使线程正常退出;二是使用interrupt方法终止处于阻塞状态的线程。
/*
	java 停止线程的方式

	方法1.  使用退出标志,使线程正常退出,也就是当run方法完成后线程终止。

	当run方法执行完后,线程就会退出。但有时run方法是永远不会结束的。如在
	服务端程序中使用线程进行监听客户端请求,或是其他的需要循环处理的任务。
	在这种情况下,一般是将这些任务放在一个循环中,如while循环。如果想让循
	环永远运行下去,可以使用while(true){……}来处理。但要想使while循环在某
	一特定条件下退出,最直接的方法就是设一个boolean类型的标志,并通过设置这
	个标志为true或false来控制while循环是否退出。下面给出了一个利用退出标志
	终止线程的例子。 
*/
class ThreadFlag implements Runnable
{
	private boolean flag;

	public void run()
	{
		while(!flag)
		{
			System.out.println(Thread.currentThread().getName() + "... run ..." +flag);
		}
	}

	public void setFlag(boolean flag)
	{
		this.flag = flag;
		System.out.println(this.flag);
	}
}

class  StopThreadDemo
{
	public static void main(String[] args) 
	{
		ThreadFlag thr_run = new ThreadFlag();
		Thread thread = new Thread(thr_run);
		thread.start();


		
		try
		{
			Thread.sleep(300);
//			thread.join();
		}
		catch (InterruptedException e)
		{
		}
			thr_run.setFlag(true);

		System.out.println("main thread exit");
	}
}


/*
	java 停止线程的方式

	方法2:  使用interrupt方法终止线程 

	使用情况:当线程调用wait方法时,或者sleep很久,线程发生阻塞时,没有外界条件促使线程被唤醒,那么线程将会
	一直保持阻塞状态,不会停止;


*/
class ThreadFlag implements Runnable
{
	public synchronized void run()
	{
		while(!Thread.interrupted())
		{
			try
			{
				this.wait();								//注意前面要配合synchronized
//				Thread.sleep(300);
//				thread.join();
			}
			catch (InterruptedException e)
			{
				System.out.println(Thread.currentThread().getName() + "... exception ..." +e);
				break;
			}
			System.out.println(Thread.currentThread().getName() + "... run ..." );

		}
	}
}

class  StopThreadDemo1
{
	public static void main(String[] args) 
	{
		ThreadFlag thr_run = new ThreadFlag();
		Thread thread = new Thread(thr_run);
		thread.start();
		
		try
		{
			Thread.sleep(1000);
//			thread.join();
		}
		catch (InterruptedException e)
		{
		}

		/*
			 在调用interrupt方法后, wait方法抛出异常,然后输出错误信息:
			 Thread-0... exception ...java.lang.InterruptedException
		*/
		thread.interrupt();
/*
    注意:在Thread类中有两个方法可以判断线程是否通过interrupt方法被终止。一个
	是静态的方法interrupted(),一个是非静态的方法isInterrupted(),这两个
	方法的区别是interrupted用来判断当前线是否被中断,而isInterrupted可以用来
	判断其他线程是否被中断。因此,while (!isInterrupted())也可以换成
	while (!Thread.interrupted())。 所以
	thread.isInterrupted是判断thread线程,调用thread.interrupt()后thread.isInterrupted()为true
	thread.interrupted是判断main线程,调用thread.interrupt()后thread.interrupted()为false
*/


//		while(!thread.isInterrupted())
//		{
//			System.out.println(" thread not exception....." );
//			thread.interrupt();
//		}
//		while(!thread.interrupted())
//		{
//			System.out.println(" thread not exception......." );
//			thread.interrupt();
//		}
		System.out.println("main thread exit。。。");
	}
}


<think>我们正在讨论Java线程基础。根据引用内容,我们知道Java程序至少启动两个线程:main线程和垃圾收集线程。同时,引用中提到了创建线程的两种方式:继承Thread类和实现Callable接口结合Future。用户要求学习Java高级特性的多线程基础教程。我们将按照以下步骤讲解:1.线程的基本概念2.创建线程的两种主要方式3.线程的生命周期4.线程的基本控制方法注意:引用中提供了两个代码示例(ThreadClassOne和Callable的使用),我们将以此为基础进行讲解。###1.线程的基本概念线程是程序执行的最小单位,一个进程可以包含多个线程Java中每个线程都独立执行特定的任务。在多线程程序中,多个线程可以并发执行,提高程序效率。###2.创建线程的方式####方式一:继承Thread类我们可以创建一个类继承`java.lang.Thread`类,并重写`run()`方法。然后创建该类的实例并调用`start()`方法启动线程。示例代码(来自引用[2]):```javapublicclassThreadClassOneextendsThread{publicvoidrun(){for(inti=1;i<10;i+=2){System.out.print(i+"");}}}```使用:```javaThreadClassOnet1=newThreadClassOne();t1.start();//启动线程,JVM会自动调用run方法```####方式二:实现Runnable接口由于Java不支持多重继承,因此更常用的方式是实现`Runnable`接口。然后将其作为参数传递给Thread类的构造函数。示例代码:```javapublicclassRunnableTaskimplementsRunnable{publicvoidrun(){for(inti=0;i<10;i+=2){System.out.print(i+"");}}}```使用:```javaRunnableTasktask=newRunnableTask();Threadt2=newThread(task);t2.start();```####方式三:使用Callable和Future(引用[2]中提到的第2关)`Callable`接口类似于`Runnable`,但它可以返回结果并抛出异常。通常与`ExecutorService`和`Future`一起使用。示例代码:```javaimportjava.util.concurrent.Callable;importjava.util.concurrent.FutureTask;publicclassCallableTaskimplementsCallable<Integer>{publicIntegercall()throwsException{intsum=0;for(inti=1;i<=10;i++){sum+=i;}returnsum;}}```使用:```javaCallableTaskcallableTask=newCallableTask();FutureTask<Integer>futureTask=newFutureTask<>(callableTask);Threadt3=newThread(futureTask);t3.start();//获取结果(会阻塞直到计算完成)Integerresult=futureTask.get();```###3.线程的生命周期线程的生命周期包括以下状态:-新建(New):创建线程对象后-就绪(Runnable):调用`start()`后,等待CPU调度-运行(Running):获得CPU时间片,执行`run()`方法-阻塞(Blocked):线程暂停执行(如等待I/O、锁等)-死亡(Terminated):线程执行完毕或异常退出###4.线程的基本控制方法-`start()`:启动线程-`run()`:定义线程执行的任务(我们重写此方法)-`sleep(longmillis)`:使当前线程休眠指定毫秒数-`join()`:等待该线程终止-`interrupt()`:中断线程(通常用于取消长时间任务)###示例:使用两种方式创建线程并运行```javapublicclassMain{publicstaticvoidmain(String[]args){//方式1:继承Thread类ThreadClassOnet1=newThreadClassOne();t1.start();//方式2:实现Runnable接口RunnableTaskrunnableTask=newRunnableTask();Threadt2=newThread(runnableTask);t2.start();}}```###注意事项-直接调用`run()`方法不会启动新线程,而是在当前线程中执行。-多个线程共享同一份数据时,需要考虑线程安全问题(后续内容)。以上是Java线程基础的核心内容。通过继承Thread类或实现Runnable/Callable接口,我们可以创建线程来执行并发任务。§§相关问题§§1.Java中如何保证线程安全?2.线程的sleep()方法和wait()方法有什么区别?3.如何停止一个正在运行的线程?4.什么是守护线程?如何设置守护线程?5.使用Callable和Future有什么优势?</think>### Java线程基础教程(高级特性) #### 一、线程基础概念 1. **线程与进程** Java程序运行时至少包含两个线程:主线程(main)和垃圾收集线程[^1]。每个线程是程序执行的最小单位,多个线程共享进程资源。 $$线程 \subset 进程 \subset JVM实例$$ 2. **线程创建方式** - **继承Thread类**(适合简单任务) ```java public class MyThread extends Thread { @Override public void run() { // 线程执行逻辑(如输出奇数) for(int i=1; i<10; i+=2) { System.out.print(i + " "); } } } ``` ```java // 启动线程 new MyThread().start(); ``` - **实现Runnable接口**(推荐方式,避免单继承限制) ```java public class MyRunnable implements Runnable { @Override public void run() { // 线程执行逻辑 } } ``` ```java // 启动线程 new Thread(new MyRunnable()).start(); ``` #### 二、线程生命周期 ```mermaid stateDiagram-v2 [*] --> New New --> Runnable : start() Runnable --> Running : 获得CPU Running --> Blocked : wait()/sleep() Blocked --> Runnable : notify()/时间到 Running --> Terminated : run()结束 ``` #### 三、线程控制方法 | 方法 | 说明 | 示例 | |------|------|------| | `start()` | 启动线程 | `thread.start()` | | `sleep()` | 暂停线程 | `Thread.sleep(1000)` | | `join()` | 等待线程结束 | `thread.join()` | | `interrupt()` | 中断线程 | `thread.interrupt()` | #### 四、Callable与Future(引用[2]) ```java import java.util.concurrent.*; public class CallableDemo implements Callable<Integer> { @Override public Integer call() throws Exception { return 42; // 返回计算结果 } public static void main(String[] args) throws Exception { ExecutorService executor = Executors.newSingleThreadExecutor(); Future<Integer> future = executor.submit(new CallableDemo()); System.out.println("结果: " + future.get()); // 获取结果 executor.shutdown(); } } ``` #### 五、线程同步机制 1. **synchronized关键字** ```java public synchronized void safeMethod() { // 线程安全代码 } ``` 2. **ReentrantLock** ```java Lock lock = new ReentrantLock(); lock.lock(); try { // 临界区代码 } finally { lock.unlock(); } ``` #### 六、线程基础 ```java ExecutorService pool = Executors.newFixedThreadPool(5); pool.execute(() -> { System.out.println("线程池任务"); }); pool.shutdown(); ```
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值