菜鸡的Java笔记 - java 线程常用操作方法

线程常用操作方法
        线程的命名操作，线程的休眠，线程的优先级
    
        线程的所有操作方法几乎都在 Thread 类中定义好了
        
    线程的命名和取得
        从本质上来讲多线程的运行状态并不是固定的。所以来讲爱那个要想确定线程的执行，唯一的区别就在于线程的名称上
        在起名的时候就应该尽可能的避免重名，或者避免修改名称
        在 Thread 类中提供有如下的方法可以实现线程名称的操作：
            构造方法： public Thread(Runnable target, String name)
            设置名字： public final void setName(String name)
            取得名字： public final String getName()
            
        既然线程的执行本身是不确定的状态，所以如果要取得线程名字的话，那么唯一能做的就是取得当前的线程名字
        所以在 Thread 类里面提供有这样的方法： public static Thread currentThread()
        
        范例：线程的命名和取得

package cn.mysterious.study3;

class MyThread implements  Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "，i = " + i);
        }
    }

}

public class StudyThread {

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

}

如果在设置线程对象是没有设置具体的名字，那么就采用一个默认的名字进行定义
            
        范例：观察代码

package cn.mysterious.study3;

class MyThread implements  Runnable{

    @Override
    public void run() {
            System.out.println("MyThread 线程类：" + Thread.currentThread().getName());
    }

}

public class StudyThread {

    public static void main(String[] args) throws Exception {
        MyThread mt = new MyThread();
        new Thread(mt).start(); // 线程启动调用 run() 方法
        mt.run(); // 直接通过对象调用 run() 方法
    }

}
/*
    结果：
    MyThread 线程类：main
    MyThread 线程类：Thread-0
*/

MyThread 线程类：main ( mt.run(); )
            MyThread 线程类：Thread-0 (new Thread(mt).start();)
            
        线程一定是依附在进程存在的，但是现在的进程在哪里呢？
            每当使用java命令在JVM上解释某一个程序执行的时候，那么都会默认的启动一个JVM的进程，而主方法只是这进程中的一个线程，所以整个程序一直都跑在线程的运行机制上
            
            每个JVM至少会启动两个线程：主线程，GC线程
            
    线程的休眠
        如果要想让某些线程延缓执行，俺么就可以使用休眠的方式来进行处理
        在 Thread 类里面提供有如下的休眠操作：
            休眠方法： public static void sleep(long millis,int nanos)throws InterruptedException
            如果休眠的时间没到就停止休眠了，那么就会产生中断异常
        范例：观察休眠

package cn.mysterious.study3;

class MyThread implements  Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "，i = " + i);
        }
    }

}
public class StudyThread {

    public static void main(String[] args) throws Exception {
        MyThread mt = new MyThread();
        new Thread(mt,"线程A").start();
        new Thread(mt,"线程B").start();
        new Thread(mt,"线程C").start();
    }

}

以上的代码执行中感觉像是所有的线程对象都同时休眠了。但是严格来讲不是同时，是有先后顺序的，只不过这个顺序小一点而已

package cn.mysterious.study3;

class MyThread implements  Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "，i = " + i);
        }
    }

}
public class StudyThread {

    public static void main(String[] args) throws Exception {
        MyThread mt = new MyThread();
        Thread t = new Thread(mt,"线程A");
        t.start();
        Thread.sleep(2000);
        t.interrupt(); // 中断

    }
}

后续会使用休眠来进行线程的分析

    线程的优先级
        从理论上来讲优先级越高的线程越有可能先执行。而在 Thread 类里面定义有一下的优先级操作方法：
            设置优先级： public final void setPriority(int newPriority)
            取得优先级： 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

        范例：观察优先级

package cn.mysterious.study3;

class MyThread implements  Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "，i = " + i);
        }
    }

}
public class StudyThread {

    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 StudyThread {

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

    }

可以发现主线程属于中等优先级或者叫一般优先级
            
    总计
        1.线程要有名字， Thread.currentThread 取得当前线程
        2.线程的休眠是有先后顺序的
        3.理论上线程的优先级越高越有可能先执行