java—多线程的常用方法（线程命名与获取，线程睡眠，线程让步，join()方法，线程停止，线程优先级）

1. 线程命名与获取

序号	线程方法	类型	作用
1	publilc Thread(Runnable target,String name)	构造方法	在创建线程的时候命名
2	public final synchronize setName(String name)	普通方法	设置线程名字
3	public final getName()	普通方法	获取线程名字
4	public static native Thread currentThread()	普通方法	取得当前对象

（1）如果线程没有设置名字，则会自动生成一个线程名。
（2）在设置线程名的时候，尽量不要重复。
（3）主方法本身就是一个线程，所有的线程都是通过主线程创建并启动的。

举例1：
线程命名与取得

package www.kelly.com;

class MyThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 5;i++){
            System.out.println("当前线程："+Thread.currentThread().getName()+":"+i);
        }
    }
}
public class TestDemo {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.run();
        new Thread(myThread).start();//没有设置名字
        new Thread(myThread,"hello").start();//设置了线程名
    }
}

2. 线程休眠（sleep方法）
   

方法	类型
public static native void sleep(long millis) throws InterruptedException	静态方法

休眠时间为毫秒（ms）

（1）线程休眠：指的是让线程暂缓执行一下，等到了预计时间之后再恢复执行。
（2）线程休眠会让出CPU，让CPU去执行其他的任务。
（3）但是sleep方法不会释放锁，也就是说如果当前线程持有对某个对象的锁，则即使调用sleep方法，其他线程也无法访问这个对象。
（4）若同时创建多个对象并启动，并设置其休眠时间，我们会错误的认为这多个线程是同时进行休眠，但是千万要记住，所有的代码是依次进入到run()方法中的。
真正进入到方法的对象可能是多个，也可能是一个。进入代码的顺序可能有差异，但是总体的执行是并发执行。

3. 线程让步（yield（）方法）
   
   （1）暂停当前正在执行的线程对象，并执行其他线程。
   （2）调用yield方法会让当前线程交出CPU权限，让CPU去执行其他的线程。
   （3）它跟sleep方法类似，同样不会释放锁。但是yield不能控制具体的交出CPU的时间。
   （4）另外，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。
   （5）线程让步会让线程回到就绪状态，而不是阻塞状态。
4. join（）方法
   
   等待该线程终止。意思就是如果在主线程中调用该方法时就会让主线程休眠，让调用该方法的线程的run（）方法先执行，完毕之后再开始执行主线程。
   举例说明：

package www.kelly.com;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

class MyThread1 implements Runnable{

    @Override
    public void run() {
        System.out.println("主线程睡眠前的时间：");
        JoinTest.printTime();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName());
        System.out.println("主线程睡眠后的时间");
        JoinTest.printTime();
    }
}

public class JoinTest {
    public static void main(String[] args) {
        MyThread1 myThread1 = new MyThread1();
        Thread thread = new Thread(myThread1,"子线程A");
        thread.start();
        System.out.println(Thread.currentThread().getName());
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("代码结束");
    }
    public static void printTime() {
        Date date=new Date();
        DateFormat format=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time=format.format(date);
        System.out.println(time);
    }
}

观察上面的代码，
（1）先执行主线程main；
（2）然后再主线程中创建了thread子线程并且启动，就开始执行thread线程的run（）方法；
（3）当打印出睡眠前的时间之后通过sleep（）让thread线程睡眠；
（4）回到主方法中继续往后走，打印了 子线程A；
（5）然后thread线程调用了join（）方法，此时就让主线程暂停，调用thread线程的run（）方法；
（6）run（）方法接着之前睡眠后的地方继续执行，执行完了之后再回到主线程，继续执行最后一句。

5. 线程停止
   
   线程停止有三种方式：
   （1） 设置标记位，可以是线程正常退出。
   （2）使用stop方法强制使线程退出，但是该方法不太安全所以已经被废弃了。
   （3） 使用Thread类中的一个 interrupt() 可以中断线程。
6. 线程优先级
   线程的优先级指的是，线程的优先级越高越有可能先执行，但仅仅是有可能而已。

• 主线程的优先级为中等优先级。
• 线程是有继承关系的，比如当A线程中启动B线程，那么B和A的优先级将是一样的。
  （1）优先级等级与定义

等级	大小
最高优先级	public final static int MAX_PRIORITY = 10;
中等优先级	public final static int NORM_PRIORITY = 5;
最低优先级	public final static int MIN_PRIORITY = 1;

（2）设置优先级与获取优先级的方法：

方法	作用
public final void setPriority(int newPriority)	设置优先级
public final int setPriority()	获取优先级

举例：
设置优先级与使用优先级的具体使用：

package www.kelly;

class MyThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0;i < 5;i++){
            System.out.println("当前线程："+Thread.currentThread().getName()+"i="+i);
        }
    }
}
public class ThreadPriorityTest {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getPriority());
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread,"1");
        Thread t2 = new Thread(myThread,"2");
        Thread t3 = new Thread(myThread,"3");
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MIN_PRIORITY);
        t3.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
        t3.start();
    }
}