Java8——线程常用操作方法

线程的命名与取得：

所有线程每一次执行都是不同的结果（因为要抢占资源），区别每一个线程要依靠名字，对于每一个线程一般会在启动前进行命名，不建议在启动之后进行命名与更改名称，或者为不同的线程设置重名的情况；

如果想进行线程名称的操作，可以使用Thread类的如下方法：

• 构造方法：public Thread （Runnable target， String name）
• 设置名字：public final void SetName（String name）
• 取得名字：public final String getName（）

但是这些方法都是Thread类里面的方法，如果在Runnable接口里面并不能实现这些方法，所以如果想取得名称的名字，那么可以取得是当前执行本方法的线程的名字。在Thread类中有一个方法：

• 取得当前线程对象：public static Thread currentThread()

范例：观察线程的命名：

class MyThread implements Runnable {
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println(Thread.currentThread().getName());
	}

}

public class test {
	public static void main(String args[]) throws Exception {
		MyThread mt = new MyThread();

		new Thread(mt).start();
		new Thread(mt).start();
		new Thread(mt).start();
	}
}

如果在实例化Thread类时没有为其设置名字，那么会自动为其设置名字，并且命名不重复；

范例：设置名字

class MyThread implements Runnable {
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println(Thread.currentThread().getName());
	}

}

public class test {
	public static void main(String args[]) throws Exception {
		MyThread mt = new MyThread();

		new Thread(mt, "自己的线程A").start();
		new Thread(mt).start(); // Thread-0
		new Thread(mt, "自己的线程B").start();
		new Thread(mt).start();// Thread-1
		new Thread(mt).start();// Thread-2
	}
}

范例：观察一个代码

class MyThread implements Runnable {
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println(Thread.currentThread().getName());
	}

}

public class test {
	public static void main(String args[]) throws Exception {
		MyThread mt = new MyThread();

		new Thread(mt, "自己的线程").start(); // 自己的线程
		mt.run(); // main
	}
}

主线程就是一个线程（main线程），那么所有在主方法上创建的线程都可以将其表示为子线程；

每当使用 java 命令去解释一个程序类的时候，对于操作系统而言，都相当于启动了一个进程，而main只是进程中的一个子线程而已；

提问：每个JVM进程启动的时候至少要启动几个线程？

• main线程：程序的主要运行，以及启动子线程；
• GC线程：负责垃圾收集；

线程的休眠：

让线程的执行速度变慢；休眠方法：

• public static void sleep（long millis）throws InterruptedException

范例：休眠的特点

class MyThread implements Runnable {
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for (int x = 0; x < 10000; x++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + ", x = " + x);
		}

	}

}

public class test {
	public static void main(String args[]) throws Exception {
		MyThread mt = new MyThread();
		new Thread(mt, "自己的线程").start(); 
	}
}

因为每一次执行到run()方法的线程对象都必须进行休眠，所以执行速度会变慢；

默认情况下，休眠时如果设置了多个对象，那么所有线程对象会一起进入run()方法（实际上时顺序进入，但是时间间隔较小可以忽略）。

线程优先级：

优先级越高越有可能先执行；在Thread类里面提供有以下两个方法：

• 设置优先级：public final void setPriority(int newPrioroty)
• 取得优先级：public final int getPriority()
• 最高优先级：public static final int MAX_PRIORITY    （10）
• 中等优先级：public static final int NORM_PRIORITY     （5）
• 最低优先级：public static final int MIN_PRIORITY      （1）

范例：

class MyThread implements Runnable {
	@Override
	public void run() {
		for (int x = 0; x < 20; x++) {
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + ", x = " + x);
		}
	}
}

public class test {
	public static void main(String args[]) throws Exception {
		MyThread mt = new MyThread();
		Thread t1 = new Thread(mt, "自己的线程对象A");
		Thread t2 = new Thread(mt, "自己的线程对象B");
		Thread t3 = new Thread(mt, "自己的线程对象C");

		t1.setPriority(Thread.MAX_PRIORITY);
		t2.setPriority(Thread.MIN_PRIORITY);
		t3.setPriority(Thread.MIN_PRIORITY);

		t1.start();
		t2.start();
		t3.start();

	}
}

范例：主线程的优先级？

public class test {
	public static void main(String args[]) throws Exception {
		System.out.println(Thread.currentThread().getPriority());   //5

	}
}

主线程属于中等优先级；