Java线程操作方法

取得和设置线程名称

//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common

// 接口名：MyThread
// 属性：
// 方法：
class MyThread_1 implements Runnable{	//实现Runnable接口
	private String name;

//	public MyThread_1(String name) {	//构造方法
//		super();
//		this.name = name;
//	}

	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		for (int i=0;i<10;i++){
//			System.out.println(name+"运行，i="+i);
			System.out.println(Thread.currentThread().getName()+",i="+i);	//取出当前线程的名称
		}
	}

}

//主类
//Function        : 	Thread_demo
public class Runnable_demo {

	public static void main(String[] args) {

		MyThread_1 mt1 = new MyThread_1();	//实例化Runnable子类对象
		new Thread(mt1).start();								//系统自动设置线程名称
		new Thread(mt1,"线程A").start();				//手工自动设置线程名称
		new Thread(mt1,"线程B").start();				//手工自动设置线程名称
		new Thread(mt1).start();								//系统自动设置线程名称
		new Thread(mt1).start();								//系统自动设置线程名称
	}

}

手工设置线程名称　　　　系统自动设置线程名称

　　　　　　　　

判断线程是否启动

使用isAlive()方法来判断线程是否已经启动而且仍然在启动

//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common

// 接口名：MyThread
// 属性：
// 方法：
class MyThread_1 implements Runnable{	//实现Runnable接口
	private String name;

	public MyThread_1(String name) {	//构造方法
		super();
		this.name = name;
	}

	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		for (int i=0;i<10;i++){
//			System.out.println(name+"运行，i="+i);
			System.out.println(Thread.currentThread().getName()+",i="+i);	//取出当前线程的名称
		}
	}

}

//主类
//Function        : 	Thread_demo
public class Runnable_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		MyThread_1 mt1 = new MyThread_1("线程A ");	//实例化Runnable子类对象
		MyThread_1 mt2 = new MyThread_1("线程B ");	//实例化Runnable子类对象
		Thread t1 = new Thread(mt1);							//实例化Thread类对象
		Thread t2 = new Thread(mt2);							//实例化Thread类对象
		System.out.println("线程开始执行之前-->"+t1.isAlive());
		t1.start();																	//启动线程
		System.out.println("线程开始执行之后-->"+t1.isAlive());
		t2.start();																	//启动线程

	}

}

主线程有可能比其他线程先执行完

线程的强制运行

在线程操作中，可以使用join()方法让一个线程强制运行，线程强制运行期间，期间线程无法运行，必须等待此线程完成之后才可以继续执行。

线程的休眠

在程序中允许一个线程进行暂时的休眠，直接使用Thread.sleep()方法即可实现休眠

程序在执行的时候，每次的输出都会间隔500ms，达到了延时操作的效果。

Thread.sleep()方法要用try和catch语句包围

//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common

// 接口名：Mythread
// 属性：
// 方法：
class Mythread implements Runnable{	//实现Runnable接口

	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		for (int i=0;i<5;i++){
			try{
				Thread.sleep(500);						//线程休眠
			}catch (Exception e){}				//需要异常处理
				System.out.println(Thread.currentThread().getName()+",i="+i);	//取出当前线程的名称
		}
	}

}

//主类
//Function        : 	ThreadSleep_demo
public class ThreadSleep_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Mythread m = new Mythread();
		new Thread(m,"线程").start();
	}

}

中断线程

当一个线程运行时，另外一个线程可以直接通过interrupt()方法中断其运行状态。

一个线程启动之后进入了休眠状态，原来是要休眠10s之后再继续执行，但是主方法在线程启动之后的2s之后就将其中断，休眠一旦中断之后将执行catch中的代码。

//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common

// 接口名：Mythread_1
// 属性：
// 方法：
class Mythread_1 implements Runnable{	//实现Runnable接口

	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		System.out.println("进入run方法");
		try{
			Thread.sleep(10000);						//线程休眠
			System.out.println("休眠完成");
				}catch (Exception e){				//需要异常处理
			System.out.println("休眠被终止");
			return;												//让程序返回被调用处
		}
		System.out.println("run方法结束");
	}

}

//主类
//Function        : 	ThreadSleep_demo
public class ThreadInterrupt_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Mythread_1 m = new Mythread_1();
		Thread t = new Thread(m,"线程");
		t.start();
		try{
			Thread.sleep(2000);			//主线程2s之后再执行中断
		}catch(Exception e){}
		t.interrupt();
	}

}

后台线程

在Java程序中，只要前台有一个线程在运行，则整个Java进程都不会消失，所以此时可以设置一个后台线程，这样即使Java进程结束了，此后台线程依然会继续执行。要想实现这样的操作，直接使用setDaemon()方法即可。

线程的优先级

在Java的线程中使用setPriority()方法可以设置一个线程的优先级，在Java的线程中一共有3种优先级。

//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common

// 接口名：MyThread
// 属性：
// 方法：
class MyThread_1 implements Runnable{	//实现Runnable接口
	private String name;

//	public MyThread_1(String name) {	//构造方法
//		super();
//		this.name = name;
//	}

	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		for (int i=0;i<10;i++){
			//System.out.println(name+"运行，i="+i);
			System.out.println(Thread.currentThread().getName()+",i="+i);	//取出当前线程的名称
		}
	}

}

//主类
//Function        : 	Thread_demo
public class Runnable_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		MyThread_1 mt1 = new MyThread_1();	//实例化Runnable子类对象
		MyThread_1 mt2 = new MyThread_1();	//实例化Runnable子类对象
		MyThread_1 mt3 = new MyThread_1();	//实例化Runnable子类对象
		Thread t1 = new Thread(mt1,"线程A");							//实例化Thread类对象
		Thread t2 = new Thread(mt2,"线程B");							//实例化Thread类对象
		Thread t3 = new Thread(mt3,"线程C");							//实例化Thread类对象
//		System.out.println("线程开始执行之前-->"+t1.isAlive());
		t1.setPriority(Thread.MIN_PRIORITY);
		t2.setPriority(Thread.NORM_PRIORITY);
		t3.setPriority(Thread.MAX_PRIORITY);
		t1.start();																	//启动线程
//		System.out.println("线程开始执行之前-->"+t1.isAlive());
		t2.start();																	//启动线程
		t3.start();																	//启动线程

//		MyThread_1 mt1 = new MyThread_1();	//实例化Runnable子类对象
//		new Thread(mt1).start();								//系统自动设置线程名称
//		new Thread(mt1,"线程A").start();				//手工自动设置线程名称
//		new Thread(mt1,"线程B").start();				//手工自动设置线程名称
//		new Thread(mt1).start();								//系统自动设置线程名称
//		new Thread(mt1).start();								//系统自动设置线程名称
	}

}

线程将根据优先级的大小来决定哪个线程会先运行，但是并非线程的优先级越高就一定会先执行，哪个线程先执行将由CPU的调度决定。

主方法的优先级是NORM，通过Thread.currentThread().getPriority()来取得主方法的优先级，结果是5

线程的礼让

在线程的操作中，可以使用yield()方法将一个线程的操作暂时让给其他线程执行。本线程暂停，让其他进程先执行。

//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common

// 接口名：MyThread
// 属性：
// 方法：
class MyThread_1 implements Runnable{	//实现Runnable接口
	private String name;

//	public MyThread_1(String name) {	//构造方法
//		super();
//		this.name = name;
//	}

	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		for (int i=0;i<10;i++){
			//System.out.println(name+"运行，i="+i);
			System.out.println(Thread.currentThread().getName()+",i="+i);	//取出当前线程的名称
			if(i==3){
				System.out.println("线程礼让：");
				Thread.currentThread().yield();	//线程礼让
			}
		}
	}

}

//主类
//Function        : 	Thread_demo
public class Runnable_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		MyThread_1 mt1 = new MyThread_1();	//实例化Runnable子类对象
		MyThread_1 mt2 = new MyThread_1();	//实例化Runnable子类对象
		MyThread_1 mt3 = new MyThread_1();	//实例化Runnable子类对象
		Thread t1 = new Thread(mt1,"线程A");							//实例化Thread类对象
		Thread t2 = new Thread(mt2,"线程B");							//实例化Thread类对象
		Thread t3 = new Thread(mt3,"线程C");							//实例化Thread类对象
//		System.out.println("线程开始执行之前-->"+t1.isAlive());
		t1.setPriority(Thread.MIN_PRIORITY);
		t2.setPriority(Thread.NORM_PRIORITY);
		t3.setPriority(Thread.MAX_PRIORITY);
		t1.start();																	//启动线程
//		System.out.println("线程开始执行之前-->"+t1.isAlive());
		t2.start();																	//启动线程
		t3.start();																	//启动线程

//		MyThread_1 mt1 = new MyThread_1();	//实例化Runnable子类对象
//		new Thread(mt1).start();								//系统自动设置线程名称
//		new Thread(mt1,"线程A").start();				//手工自动设置线程名称
//		new Thread(mt1,"线程B").start();				//手工自动设置线程名称
//		new Thread(mt1).start();								//系统自动设置线程名称
//		new Thread(mt1).start();								//系统自动设置线程名称
	}

}

 　　　　线程礼让也是不一定的