Java 线程的常用操作方法

目录

• 线程命名和取得
• 线程的休眠
• 线程优先级（priority）

线程命名和取得

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

• 构造方法：public Thread(Runnable target,String name);
• 设置名字：public final void setName(String name);//final方法不允许覆写
• 取得名字：public final String getName();
  
  如果没有为线程设置名字，会自动为线程设置不重复的名字

/**
 *
 * 2017-10-08
 * @author Junwei Zhu
 *
 */
class MyThread03 implements Runnable
{

    @Override
    public void run() {
        //取得当前线程的名字
        System.out.println(Thread.currentThread().getName());
    }

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

Thread-0
Thread-1
Thread-2

自动定义线程名字

/**
 *
 * 2017-10-08
 * @author Junwei Zhu
 *
 */
class MyThread03 implements Runnable
{

    @Override
    public void run() {
        //取得当前线程的名字
        System.out.println(Thread.currentThread().getName());
    }

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

        //main()方法可以看成是一个主线程，在主线程下创建的线程可以看成是子线程
        mt.run();

    }
}

main
自己的线程A
自己的线程B
自己的线程C

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

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

线程的休眠

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

public static void sleep(long mills)throws InterruptedException//中断异常

package thread;
/**
 * 线程休眠
 * 每一次执行到run()方法的线程对象都必须进行休眠，所以执行的速度就会变慢
 * 默认情况下，如果设置了多个线程对象，那么所有的线程对象将一起进去到run()方法（所谓一起进入是因为先后顺序太短了）
 * 2017-10-09
 * @author Junwei Zhu
 */
class MyThread03 implements Runnable
{
	@Override
	public void run() {
		for(int x=0;x<1000;x++) {
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//取得当前线程的名字
		System.out.println(Thread.currentThread().getName()+",x="+x);
		}
	}
}
public class GetNameThread {
	public static void main(String[] args) {
		MyThread03 mt = new MyThread03();
		new Thread(mt,"自己的线程A").start();
		new Thread(mt,"自己的线程B").start();
		new Thread(mt,"自己的线程c").start();
	}
}

自己的线程c,x=0
自己的线程B,x=0
自己的线程A,x=0
自己的线程c,x=1
自己的线程A,x=1
自己的线程B,x=1
自己的线程A,x=2
自己的线程B,x=2
自己的线程c,x=2
自己的线程c,x=3
自己的线程B,x=3
自己的线程A,x=3
自己的线程A,x=4
自己的线程B,x=4
...

线程优先级（priority）

所谓的优先级指的是越高的优先级，越有可能先执行。在Thread类里面提供了两个方法：

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

设置和取得优先级都是使用int数据类型，对于此内容有三种取值:

• 最高优先级：public static final int MAX_PRIORITY;
• 中等优先级：public static final int NORM_PRIORITY;
• 最低优先级：public static final int M_PRIORITY;

class MyThread implements Runnable
{

    @Override
    public void run() {
        for(int x = 0;x<20;x++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+",x="+x);
        }
    }
}
public class PriorityThreadTest {
    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();
    }
}

自己的线程A,x=0
自己的线程B,x=0
自己的线程C,x=0
自己的线程A,x=1
自己的线程C,x=1
自己的线程B,x=1
自己的线程A,x=2
自己的线程C,x=2
自己的线程B,x=2
自己的线程A,x=3
自己的线程C,x=3
自己的线程B,x=3
自己的线程A,x=4
自己的线程C,x=4
自己的线程B,x=4
自己的线程A,x=5
自己的线程C,x=5
自己的线程B,x=5
自己的线程A,x=6
自己的线程C,x=6
自己的线程B,x=6
自己的线程A,x=7
自己的线程C,x=7
自己的线程B,x=7
...

可以看到基本上都是A线程先执行。