Osheep

时光不回头,当下最重要。

Java线程常用操作方法

导语

开篇废话,多线程开发很重要,所以很有必要了解一下线程的常用操作方法,更加方便地使用多线程。其实主要会用sleep()方法就够用了。

主要内容

  • 线程常用操作方法

具体内容

多线程有很多的方法定义,但是大部分的方法都是在Thread类里面定义,强调几个与我们开发有关的方法。

线程的命名与取得

所有的线程程序的执行,每一次都是不同的运行结果,因为它会根据自己的情况进行资源抢占,所以如果要想区分每一个线程,那么就必须依靠线程的名字。对于线程的名字一般而言会在其启动之前进行定义,不建议对已经启动的线程进行更改名称,或者是为不同的线程设置重名的情况。

如果想要进行线程名称的操作,可以使用Thread类的如下方法:

  • 构造方法:public Thread (Runable target, String name)。
  • 设置名字:public final void setName(String name)。
  • 取得名字:public final String getName()。

对于线程名字的操作会出现一个问题,这些方法是属于Thread类里面的,可是如果换回到线程类(Runnable子类),这个类里面并没有继承Thread类,所以如果要想取得线程名字,那么能够取得的就是当前执行本方法的线程名字。所以在Thread类里面提供有一个方法:

  • 取得当前线程对象:public static void Thread currentThread()。

范例:观察线程的命名

class MyThread implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

public class TestDemo {
    public static void main(String args[]) {
        MyThread mt = new MyThread();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
    }
}

输出结果:

Thread-0
Thread-1
Thread-2

如果在实例化Thread类对象的时候没有为其设置名字,那么会自动的进行编号命名,也就是说保证线程对象的名字不重复。

范例:修改代码设置名字

public class TestDemo {
    public static void main(String args[]) {
        MyThread mt = new MyThread();
        new Thread(mt, "自己的线程A").start();
        new Thread(mt).start();
        new Thread(mt", 自己的线程B").start();
    }
}

JDK1.8输出结果:

自己的线程A
Thread-0
自己的线程B

范例:修改代码

public class TestDemo {
    public static void main(String args[]) {
        MyThread mt = new MyThread();
        new Thread(mt, "自己的线程A").start();
        mt.run();  // 直接调用run()方法,main
    }
}

输出结果

main
自己的线程A

原来主方法就是一个线程(main线程),那么所有在主方法上创建的线程实际上都可以将其表示为子线程。
通过以上的代码可以发现,线程实现上一直都存在(主方法就是主线程),可是进程去哪里了呢?

public class Test {
    public static void main(String args[]) {
        for(long i = 0; i < 2000000000; i++);
    }
}

查看任务管理器,出现java进程。
每当使用java命令去解释一个程序类的时候,对于操作系统而言,都相当于启动了一个新的进程,而main只是进程上的一个子线程而已。

提问:每一个JVM进程启动的时候至少启动几个线程?

  • main线程:程序的主要执行,以及启动子线程。
  • gc线程:负责垃圾收集。

线程的休眠

所谓的线程的休眠指的就是让线程的执行速度稍微变慢一点。
休眠的方法:

  • public static void sleep(long millis) throws InterruptedException

范例:观察sleep()方法

class MyThread implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 10000; i++) {
            try {
                Thread.sleep(1000);
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ",x = " + x);
        }
    }
}

public class TestDemo {
    public static void main(String args[]) {
        MyThread mt = new MyThread();
        new Thread(mt, "自己的线程A").start();
    }
}

发现程序的速度变慢了,因为每一次循环执行都必须进行休眠,所以执行速度就会变慢。

修改代码观察

public class TestDemo {
    public static void main(String args[]) {
        MyThread mt = new MyThread();
        new Thread(mt, "自己的线程A").start();
        new Thread(mt, "自己的线程B").start();
        new Thread(mt, "自己的线程C").start();
        new Thread(mt, "自己的线程D").start();
        new Thread(mt, "自己的线程E").start();
    }
}

输出发现,在休眠的时候如果设置了多个线程对象,那么所有的线程对象将一起进入到run()方法(所谓的一起进入实际上是因为先后顺序实在是太短了,但实际上有区别),一起休眠,一起再进入run()方法。

线程优先级

所谓的优先级指的是越高的优先级,越有可能先执行。在Thread类里面提供有以下的两个方法进行优先级操作:

  • 设置优先级:public final void setPriority(int newPriority)。
  • 取得优先级:public final int getPriority()。

发现设置和取得优先级都是使用了int数据类型,对于此内容有三种聚会:

  • 最高优先级:public static final int MAX_PRIORITY,10。
  • 中等优先级:public static final int NORM_PRIORITY,5。
  • 最低优先级:public static final int MIN_PRIORITY,0。

范例:测试优先级

class MyThread implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 20; i++) {
            try {
                Thread.sleep(1000);
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ",x = " + x);
        }
    }
}

public class TestDemo {
    public static void main(String args[]) {
        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);
        t1.start();
        t2.start();
        t3.start();
    }
}

范例:主线程的优先级为多少

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

输出结果

5

主线程属于中等优先级。

总结

  • Thread.currentThread()可以取得当前线程类对象。
  • Thread.sleep()主要是休眠,感觉是一起休眠,但实际上是有先后顺序的。
  • 优先级越高的线程对象越有可能先执行。

更多内容戳下面:

点赞