线程常用操作方法

1、线程的命名和取得

多线程的操作方法主要都在Thread类中定义。多线程的运行状态是不确定的，在程序开发过程中获取需要使用的线程需要通过线程的名字来进行操作。在Thread类中提供的线程名称处理：

构造方法：public Thread(Runnable target, String name);

设置名字：public final void setName(String name);

取得名字：public final String getName();

因为线程的状态不可控，所以对线程对象的获取不能仅依靠this来完成，但是所有的线程一定会执行run()方法，那么可以考虑获取当前线程：public static Thread currentThread();->利用构造方法或setName()方法设置线程名字后，通过Thread.currentThread().getName();获取

没有命名的线程系统会自动结合编号命名，Thread-0...这种命名主要依靠static属性完成，在Thread类定义有如下操作：

private static int threadInitNumber;
private static synchronized int nextThreadNum() {
    return threadInitNumber++;
}

当时用myThreade.run()在主方法之中调用线程类对象中的run()方法（在该方法中输出当前进程的名字）所获得的线程对象的名字为“main”,

即表明，主方法也是一个线程。

当使用java命令执行程序的时候就表示启动了一个JVM的进程，一台电脑可以同时启动多个JVM进程，每一个JVM的进程都会有各自的线程。在开发中，主线程可以创建若干个子线程，创建子线程的目的是可以将一些复杂逻辑或耗时逻辑交由子线程处理。

示例：

public class Demo {
    public static void main(String[] args) throws Exception {
        System.out.println("1.执行任务一");
        new Thread(()-> { //耗时逻辑处理交由子线程
            int temp = 0 ;
            for(int x = 0 ; x < Integer.MAX_VALUE ; x ++) {
                temp += x ;
            }
            System.out.println(temp);
        }).start();
        System.out.println("3.执行任务三");
        System.out.println("N.执行任务N");
    }
}

2、线程的休眠——使线程暂缓执行，主要特点是可以实现线程的唤醒，以继续进行后续的处理。

在Thread类中定义的线程休眠方法：

public static void sleep​(long millis) throws InterruptedException（休眠单位：毫秒）

public static void sleep​(long millis,int nanos) throws InterruptedException（休眠单位：毫秒、纳秒）

在中断的过程中会产生中断异常“InterruptedException”，中断异常属于Exception子类，所以该异常必须进行处理。

public class Demo {
    public static void main(String[] args) throws Exception {
        System.out.println("1.执行任务一");
        new Thread(()-> { //耗时逻辑处理交由子线程
            for(int x = 0 ; x < 10 ; x ++) {
                System.out.println(Thread.currentThread().getName() +"," + x);
            }
            try {
                Thread.sleep(100); //暂缓执行
            }catch(InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        System.out.println("3.执行任务三");
        System.out.println("N.执行任务N");
    }
}
如果有多个线程对象，那么休眠是有先后顺序的。示例：产生多个线程对象进行休眠处理：

public class Demo {
    public static void main(String[] args) throws Exception {
        System.out.println("1.执行任务一");
        for(int num = 0 ; num < 3 ; num ++) { //三个线程对象
            new Thread(()-> { //耗时逻辑处理交由子线程
                for(int x = 0 ; x < 5 ; x ++) {
                    System.out.println(Thread.currentThread().getName() +"," + x);
                }
                try {
                    Thread.sleep(100); //暂缓执行
                }catch(InterruptedException e) {
                    e.printStackTrace();
                }
            },"线程对象-" + num).start();
        }
        System.out.println("3.执行任务三");
        System.out.println("N.执行任务N");
    }
}
3、线程中断（被其他线程中断）

在Thread类中中断执行的方法：

判断线程是否被中断的方法：public boolean isInterrupted​()

若某线程未被中断，则在当前线程中断未被中断的线程：public void interrupt();

中断线程必须进行异常处理。

4、线程强制执行

指的是当满足某些条件后，某一个线程对象可以一直独占资源，直到该线程的程序执行结束。

首先获得主线程对象：Thread mainThread = Thread.currentThread() ;

然后才能在其他线程中，让主线程强制执行：mainThread.join();

5、线程礼让（让出资源）：public static void yield();每一次调用yield()方法都只会礼让一次当前的资源。

6、线程优先级

从理论上讲线程的优先级越高越有可能先执行（越有可能先抢占到资源），在Thread类中相关方法：

设置优先级：public final void setPriority(int newPriority);

获取优先级：public final int getPriority();

在进行优先级定义的时候是通过int型数字来完成的，对于此数字的选择在Thread类中有三个定义：

最高优先级：public static final int MAX_PRIORITY；10

中等优先级：public static final int NORM_PRIORITY；5

最低优先级：public static final int MIN_PRIORITY；1

使用格式：thread.setPriority(Thread.MAX_PRIORITY);

主方法是一个主线程，而主线程是中等优先级，默认创建的线程优先级也是中等优先级（5）