菜鸡的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.理论上线程的优先级越高越有可能先执行

巴特西

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

最新文章

热门文章