线程的操作方法
在多线程中所有的操作方法实际上都是从Thread类开始的。所有的操作基本上都是Thread类中。
下面看看线程类中的方法：
1.获取和设置线程的名称
在Thread类中可以通过getName()方法取得线程的名字，通过setName()方法给线程设置名称
线程的名称一般在启动线程前设置，但也允许为已经运行的线程设置名称。允许两个Thread对象有相同的名字，但为了清晰，应当经量避免这中情况出现。
另外，如果程序并没有为线程起名字，则系统会自动为线程分配一个名称 实例：
public class MyThreadDemo implements Runnable{ }
public void run() {
for (int i = 0; i < 10; i++) {
//currentThread()获取当前正在执行的线程对象 System.out.println(Thread.currentThread().getName()+\"运行，i=\"+i); } }
public class ThreadDemo1 { public static void main(String[] args) { }
}
//创建目标对象
MyThreadDemo mt=new MyThreadDemo(); //创建并启动线程（系统自动设置线程名称） new Thread(mt).start(); //手动设置线程名称
new Thread(mt,\"线程1\").start(); new Thread(mt,\"线程2\").start();
从执行结果来看，指定的名称会自动出现，如果没有指定会发现线程会使用自动编号的方式完成，按照Thread-0,Thread-1依次编号，实际上他肯定是在类中存在一个Static属性，来记录编号的。
2.获取当前正在执行的线程对象
程序我们使用currentThread()静态方法获取到当前正在运行线程的对象。 实例：
public class MyThreadDemo2 implements Runnable { public void run() { }
for(int i=0;i<10;i++){ System.out.println(Thread.currentThread().getName()+\"运行，i=\"+i); } }
public class TreadDemo2 {
public static void main(String[] args) { //创建目标对象
MyThreadDemo2 mt=new MyThreadDemo2(); //启动线程
new Thread(mt,\"线程1\").start(); //调用run方法 mt.run(); } }
通过上面的程序你会发现，程序中由于直接通过线程的目标对象调用里面的run()方法，所以输出结果中就包含了一个“main”,此线程就是由“ mt.run();”产生的。因为此法是由主方法完成的，也就是说实际上主方法本身也是一个线程-----主线程。
问出现啦，既然主方法都是以线程的形式出现的，那么Java程序运行时到底启动了多少个线程？
答案是至少启动了两个线程。
从之前的学习来看，每当Java程序执行的时候，实际上都会启动一个jvm，没一个jvm实际上就是在操作系统中启动一个进程。Java本身具备了垃圾收集机制，所以在Java程序运行时至少启动两个线程：主线程，GC。
3.判断线程是否启动
在Java中使用isAlive()方法来判断线程是否启动，如果是true就说明线程启动，false就是没有启动。
实例：
public class MyThreadDemo3 implements Runnable{
public void run() {
for(int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+\"运行，i=\"+i);
}
} }
public class ThreadDemo3 {
public static void main(String args[]) { //创建一个线程目标对象 } }
MyThreadDemo3 mt=new MyThreadDemo3(); //创建线程对象
Thread th1=new Thread(mt,\"线程1\"); //isAlive()方法判断线程是否启动
System.out.println(\"线程启动之前=\"+th1.isAlive()); th1.start();//启动线程
System.out.println(\"线程启动之后=\"+th1.isAlive()); for (int i = 0; i <10; i++) { System.out.println(\"main(主线程运行) ，i=\"+i);
}
System.out.println(\"当前程序中的for循环执行后=\"+th1.isAlive());
4.线程的强制运行
在Java中的线程操作中，可以使用join()方法让一个线程强制运行，线程强制运行期间，其他的线程无法执行，必须等到强制执行的线程执行完毕之后，才可执行其他线程。 实例：
public class MyThreadDemo4 implements Runnable{ }
public class ThraedDemo4 { public static void main(String[] args) { MyThreadDemo4 mt=new MyThreadDemo4(); Thread th1=new Thread(mt,\"线程1\");
th1.start();
for (int i = 0; i < 50; i++) { if(i>10){ try { th1.join(); public void run() {
for(int i=0;i<50;i++){ } }
System.out.println(Thread.currentThread().getName()+\"运行，i=\"+i);
}
} }
} catch (InterruptedException e) {
e.printStackTrace(); } }
System.out.println(\"main线程，运行，i=\"+i);
5.线程休眠
使用休眠可以让线程暂停执行。
在Java的线程操作中使用sleep()静态方法让线程休眠。 实例：
public class MyThreadDemo5 implements Runnable{ }
public void run() { }
for(int i=0;i<50;i++){ try { Thread.sleep(1000);
} catch (InterruptedException e) { e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+\"运行，i=\"+i); }
public class ThreadDemo5 { }
public static void main(String[] args) { MyThreadDemo5 mt=new MyThreadDemo5(); }
Thread th=new Thread(mt,\"线程1\"); th.start();
6.线程的中断
一个线程可以被另一个线程中断其操作的状态，使用Interrupt()方法完成
当一个线程运行的时候，另一个线程可以直接Interrupt()方法，中断其运行状态。 实例：
public class MyThreadDemo6 implements Runnable{ public void run() {
System.out.println(\"1.进入run()方法\");
try { }
public class ThreadDemo6 {
public static void main(String[] args) { }
MyThreadDemo6 mt=new MyThreadDemo6(); Thread th=new Thread(mt,\"线程1\"); th.start(); try { Thread.sleep(2000);
} catch (InterruptedException e) { System.out.println(\"休眠被终止\"); }
th.interrupt(); }
Thread.sleep(10000); System.out.println(\"2.线程完成休眠\"); } catch (InterruptedException e) { System.out.println(\"3.休眠被终止\"); }
return;
System.out.println(\"4.run()方法正常执行结束\");
7.后台线程
在Java中，只要一个程序没有执行完成（就是还有一个线程在运行），则整个Java的进程是不会消失的，所以，此时可以设置一个后台线程，这样即使Java的进程结束，此后他程序依然会继续执行。
直接使用setDaemon()方法就可以完成上述内容。
实例：
public class MyThreadDemo7 implements Runnable{ public void run() { }
public class ThreadDemo7 { public static void main(String[] args) {
while(true){
System.out.println(Thread.currentThread().getName()+\"正在运行！\"); } }
}
}
MyThreadDemo7 mt=new MyThreadDemo7(); Thread thread=new Thread(mt,\"线程1\"); //设置后台运行
thread.setDaemon(true); thread.start();
线程的优先级
在Java中的线程操作中，所有的线程运行前都会保持在就绪状态，那么此时，那个线程的优先级高，那个线程就有可能会先被执行。
实例：
public class MyThreadDemo8 implements Runnable{ }
public void run() {
for (int i = 0; i < 50; i++) { try { Thread.sleep(500); } }
} catch (InterruptedException e) { e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+\"运行，i=\"+i);
public static void main(String[] args) { }
看看主方法的优先级 实例：
public class ThraedDemo9 {
}
Thread th1=new Thread(new MyThreadDemo8(),\"线程1\"); Thread th2=new Thread(new MyThreadDemo8(),\"线程2\"); Thread th3=new Thread(new MyThreadDemo8(),\"线程3\"); //设置优先级setPriority()
th1.setPriority(Thread.MAX_PRIORITY);//最高优先级 th2.setPriority(Thread.NORM_PRIORITY);//中等优先级 th3.setPriority(Thread.MIN_PRIORITY);//最低的优先级 th1.start(); th2.start(); th3.start();
public static void main(String[] args) {
System.out.println(\"主线程的优先级是：\"+Thread.currentThread().getPriority()); } }
主线程的优先级的结果是“5”，数字“5”对应的就是Thread.NORM_PRIORITY这个优先级，所以主线程的优先级是中等级别。 public class ThraedDemo9 {
public static void main(String[] args) {
System.out.println(\"Thread.MAX_PRIORITY：\"+Thread.MAX_PRIORITY); System.out.println(\"Thread.NORM_PRIORITY:\"+Thread.NORM_PRIORITY); System.out.println(\"Thread.MIN_PRIORITY：\"+Thread.MIN_PRIORITY); }
}
运行结果是：
Thread.MAX_PRIORITY：10 Thread.NORM_PRIORITY:5 Thread.MIN_PRIORITY：1
线程的礼让
在线程的操作中，也可以使用yield()方法将一个线程的操作暂时让给其他线程执行。
实例：
public class MyThreadDemo10 implements Runnable{ }
public class ThreadDemo10 { public static void main(String[] args) { MyThreadDemo10 mt=new MyThreadDemo10(); Thread th1=new Thread(mt,\"线程1\");
Thread th2=new Thread(mt,\"线程2\");
th1.start(); th2.start(); } }
public void run() {
for(int i=0;i<50;i++){ } }
System.out.println(Thread.currentThread().getName()+\"运行，i=\"+i); if(i==10){ }
System.out.println(\"线程礼让！！！\"); Thread.currentThread().yield();
因篇幅问题不能全部显示，请点此查看更多更全内容