导语
开篇废话，多线程开发很重要，所以很有必要了解一下线程的常用操作方法，更加方便地使用多线程。其实主要会用sleep()方法就够用了。
主要内容
- 线程的命名与取得
- 线程的休眠
- 线程的优先级
具体内容
多线程有很多的方法定义，但是大部分的方法都是在Thread类里面定义，强调几个与我们开发有关的方法。
线程的命名与取得
所有的线程程序的执行，每一次都是不同的运行结果，因为它会根据自己的情况进行资源抢占，所以如果要想区分每一个线程，那么就必须依靠线程的名字。对于线程的名字一般而言会在其启动之前进行定义，不建议对已经启动的线程进行更改名称，或者是为不同的线程设置重名的情况。
如果想要进行线程名称的操作，可以使用Thread类的如下方法：
- 构造方法：public Thread (Runable target, String name)。
- 设置名字：public final void setName(String name)。
- 取得名字：public final String getName()。
对于线程名字的操作会出现一个问题，这些方法是属于Thread类里面的，可是如果换回到线程类（Runnable子类），这个类里面并没有继承Thread类，所以如果要想取得线程名字，那么能够取得的就是当前执行本方法的线程名字。所以在Thread类里面提供有一个方法：
- 取得当前线程对象：public static void Thread currentThread()。
范例：观察线程的命名
class MyThread implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
public class TestDemo {
public static void main(String args[]) {
MyThread mt = new MyThread();
new Thread(mt).start();
new Thread(mt).start();
new Thread(mt).start();
}
}
输出结果：
Thread-0
Thread-1
Thread-2
如果在实例化Thread类对象的时候没有为其设置名字，那么会自动的进行编号命名，也就是说保证线程对象的名字不重复。
范例：修改代码设置名字
public class TestDemo {
public static void main(String args[]) {
MyThread mt = new MyThread();
new Thread(mt, "自己的线程A").start();
new Thread(mt).start();
new Thread(mt", 自己的线程B").start();
}
}
JDK1.8输出结果：
自己的线程A
Thread-0
自己的线程B
范例：修改代码
public class TestDemo {
public static void main(String args[]) {
MyThread mt = new MyThread();
new Thread(mt, "自己的线程A").start();
mt.run(); // 直接调用run()方法，main
}
}
输出结果
main
自己的线程A
原来主方法就是一个线程（main线程），那么所有在主方法上创建的线程实际上都可以将其表示为子线程。
通过以上的代码可以发现，线程实现上一直都存在（主方法就是主线程），可是进程去哪里了呢？
public class Test {
public static void main(String args[]) {
for(long i = 0; i < 2000000000; i++);
}
}
查看任务管理器，出现java进程。
每当使用java命令去解释一个程序类的时候，对于操作系统而言，都相当于启动了一个新的进程，而main只是进程上的一个子线程而已。
提问：每一个JVM进程启动的时候至少启动几个线程？
- main线程：程序的主要执行，以及启动子线程。
- gc线程：负责垃圾收集。
线程的休眠
所谓的线程的休眠指的就是让线程的执行速度稍微变慢一点。
休眠的方法：
- public static void sleep(long millis) throws InterruptedException
范例：观察sleep()方法
class MyThread implements Runnable {
@Override
public void run() {
for(int i = 0; i < 10000; i++) {
try {
Thread.sleep(1000);
} catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "，x = " + x);
}
}
}
public class TestDemo {
public static void main(String args[]) {
MyThread mt = new MyThread();
new Thread(mt, "自己的线程A").start();
}
}
发现程序的速度变慢了，因为每一次循环执行都必须进行休眠，所以执行速度就会变慢。
修改代码观察
public class TestDemo {
public static void main(String args[]) {
MyThread mt = new MyThread();
new Thread(mt, "自己的线程A").start();
new Thread(mt, "自己的线程B").start();
new Thread(mt, "自己的线程C").start();
new Thread(mt, "自己的线程D").start();
new Thread(mt, "自己的线程E").start();
}
}
输出发现，在休眠的时候如果设置了多个线程对象，那么所有的线程对象将一起进入到run()方法（所谓的一起进入实际上是因为先后顺序实在是太短了，但实际上有区别），一起休眠，一起再进入run()方法。
线程优先级
所谓的优先级指的是越高的优先级，越有可能先执行。在Thread类里面提供有以下的两个方法进行优先级操作：
- 设置优先级：public final void setPriority(int newPriority)。
- 取得优先级：public final int getPriority()。
发现设置和取得优先级都是使用了int数据类型，对于此内容有三种聚会：
- 最高优先级：public static final int MAX_PRIORITY，10。
- 中等优先级：public static final int NORM_PRIORITY，5。
- 最低优先级：public static final int MIN_PRIORITY，0。
范例：测试优先级
class MyThread implements Runnable {
@Override
public void run() {
for(int i = 0; i < 20; i++) {
try {
Thread.sleep(1000);
} catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "，x = " + x);
}
}
}
public class TestDemo {
public static void main(String args[]) {
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);
t1.start();
t2.start();
t3.start();
}
}
范例：主线程的优先级为多少
public class TestDemo {
public static void main(String args[]) {
System.out.println(Thread.currentThread().getPriority());
}
}
输出结果
5
主线程属于中等优先级。
总结
- Thread.currentThread()可以取得当前线程类对象。
- Thread.sleep()主要是休眠，感觉是一起休眠，但实际上是有先后顺序的。
- 优先级越高的线程对象越有可能先执行。
