Java复习之线程的操作方法

这篇博客主要是总结一下Java中线程常用的操作方法。

Thread(Runnable target)
分配一个新的Thread对象

Thread(Runnable target,String name)
分配新的Thread对象，并给线程命名

Thread(String name)
分配新的Thread对象

static Thread currentThread()
返回当前正在执行的线对象的引用

long getId()
返回线程的标识符

String getName()
返回线程的名称

void setName(String name)
改变线程名称，使之与参数name相同

boolean isAlive()
测试线程是否处于活动状态

Demo：

public class ThreadDemo {
    public static void main(String args[])
    {
        MyThread myThread=new MyThread();
        //实例化一个线程对象并给其赋值
        Thread thread=new Thread(myThread,"小白线程");
        //获取线程的ID
        System.out.println(thread.getId());
        //设置线程的名称
        thread.setName("小黑线程");
        thread.start();
        System.out.println("thread线程是否活动"+thread.isAlive());
    }
}
class MyThread implements Runnable
{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

static void sleep(long millis)
休眠指定的毫秒继续执行
sleep方法休眠完成后，线程会重新恢复到就绪状态

sleep方法的原理
让当前线程进入休眠状态，让出当次执行的CPU时间，但是不丢失监视器的所属权。

static void sleep(long millis,int nanos)
休眠指定毫秒 纳秒之后继续执行

Demo：

public class ThreadDemo2 {
    public static void main(String args[])
    {
        MyThread2 myThread2=new MyThread2();
        Thread thread=new Thread(myThread2);
        thread.start();
        for(int i=0;i<10;i++)
        {
            System.out.println(Thread.currentThread().getName()
                    +"-"+i+" ");
            //让当前线程进入休眠状态
            try {
                Thread.sleep(1000);
            }catch (InterruptedException ex)
            {
                ex.printStackTrace();
            }
        }
    }
}
class MyThread2 implements Runnable
{
    @Override
    public void run() {

        for (int i=0;i<10;i++)
        {
            System.out.println(Thread.currentThread().getName()
                    +"-"+i);
            try {
                //让当前线程进入休眠状态
                Thread.sleep(1000);
            }catch (InterruptedException ex)
            {
                ex.printStackTrace();
            }
        }
    }
}

void join()
等待调用该方法的线程执行完毕之后，再去执行其他线程

void join(long millis)
等待该线程终止的时间最长为milli毫秒

void join(long millis,int nanos)
等待该线程的终止的时间最长毫秒 纳秒

Demo：

public class ThreadDemo3 {
    public static void main(String args[])
    {
        MyThread3 myThread3=new MyThread3();
        Thread thread=new Thread(myThread3);
        thread.start();

        for (int i=0;i<9;i++)
        {
            System.out.println("Main"+i);
            if(i==5)
            {
                try {
                    //等待thread线程终止在执行主线程
                    thread.join();
                }catch (InterruptedException ex)
                {
                    ex.printStackTrace();
                }
            }
            try {
                Thread.sleep(1000);
            }catch (InterruptedException ex)
            {
                ex.printStackTrace();
            }
        }
    }
}
class MyThread3 implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<8;i++)
        {
            System.out.println(Thread.currentThread().getName()+"-"+i);
            try {
                Thread.sleep(1000);
            }catch (InterruptedException ex)
            {
                ex.printStackTrace();
            }
        }
    }
}

void interrupt()
中断线程

static boolean interrupted()
测试当前线程是否已经中断

void setPriority(int newPriority)
更改线程的优先级

优先级高的线程也不一定百分百抢到CPU，只是说抢到的概率大一些

static int MAX_PRIORITY
线程可以具有的最高优先级

static int MIN_PRIORITY
线程可以具有的最低优先级

static int NORM_PRIORITY
分配给线程的默认优先级

Demo：

/**
 * 中断线程
 * 1.Interrupt()方法只是设置了线程的中断标记为true，并没有真正的中断线程，线程还在执行
 *  真正中断线程还是得自身中断
 * 2.自定义标记完成中中断
 */
/**
 * 设置线程的优先级
 */
public class ThreadDemo4 {
    public static void main(String args[])
    {
        MyThread4 myThread4=new MyThread4();
        Thread thread=new Thread(myThread4,"t1");
        //start方法是开辟新的线程执行run()方法
        Mythread5 mythread5=new Mythread5();
        Thread thread1=new Thread(mythread5,"t2");

        //设置线程的优先级
        thread.setPriority(Thread.MAX_PRIORITY);
        thread1.setPriority(Thread.MIN_PRIORITY);
        thread.start();
        thread1.start();
        for (int i=0;i<7;i++)
        {
            System.out.println("Main-"+i);
            if(i==5)
            {
                //thread.interrupt();//设置中断标记（中断状态为True）
                mythread5.setFlag(false);//中断线程
            }
            try {
                Thread.sleep(1000);
            }catch (InterruptedException ex)
            {
                ex.printStackTrace();
            }
        }
    }
}
class MyThread4 implements Runnable
{
    @Override
    public void run() {
        for (int i=0;i<7;i++)
        {
            System.out.println(Thread.currentThread().getName()+i);
            try {
                Thread.sleep(1000);
            }catch (InterruptedException ex)
            {
                ex.printStackTrace();
            }
        }
    }
}
class Mythread5 implements Runnable{
    private boolean flag = true;
    public boolean isFlag()
    {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        int i=0;
        while (flag)
        {
            System.out.println(Thread.currentThread().getName()+i);
            i++;
            try {
                Thread.sleep(1000);
            }catch (InterruptedException ex)
            {
                ex.printStackTrace();
            }
        }
    }
}

线程可以分为用户线程与守护线程，我们自己创建的线程一般为用户线程，守护线程是指当程序中没有用户线程的时候，所有的守护线程都会终止，如GC 垃圾回收机制

boolean isDaemon()
测试该线程的是否为守护线程

void setDaemon(boolean on)
将该线程标记为守护线程或者用户线程

static void yield()
暂停当前正在执行的线程对象，并执行其他线程让出本次的执行权，只让一次

public class ThreadDemo5 {
    public static void main(String args[])
    {
        MyThread6 myThread6=new MyThread6();
        Thread thread=new Thread(myThread6);
        //设置线程为守护线程
       // thread.setDaemon(true);
        thread.start();
        for(int i=0;i<10;i++)
        {
            System.out.println("Main-"+i);
            if(i==5)
            {
                //让出当次的cpu的执行时间
                Thread.yield();
            }
            try {
                Thread.sleep(1000);
            }catch (InterruptedException ex)
            {
                ex.printStackTrace();
            }
        }
    }
}

class MyThread6 implements Runnable{
    @Override
    public void run() {
        for (int i=0;i<20;i++)
        {
            System.out.println("Mythread6-"+i);
            try {
                Thread.sleep(1000);
            }catch (InterruptedException ex)
                {
                    ex.printStackTrace();
                }
        }
    }
}