多线程常用操作方法

最新推荐文章于 2024-05-12 13:12:54 发布

koala__

最新推荐文章于 2024-05-12 13:12:54 发布

阅读量176

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/koala__/article/details/89814389

版权

JavaSE 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1 线程命名与取得

public Thread(Runnable target,String name),创建线程的时候设置名称
public final synchronized void setName(String name),设置线程名称
public final String getName(),取得线程名字
public static native Thread currentThread(),取得当前线程对象

class MyThread implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<3;i++) {
            System.out.println("当前线程：" + Thread.currentThread().getName() + ",i=" + i);
        }
    }
}
public class Test{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        new Thread(myThread).start();
        new Thread(myThread).start();
        new Thread(myThread,"thread1").start();
    }
}

当前线程：Thread-0,i=0
当前线程：Thread-0,i=1
当前线程：Thread-0,i=2
当前线程：Thread-1,i=0
当前线程：Thread-1,i=1
当前线程：Thread-1,i=2
当前线程：thread1,i=0
当前线程：thread1,i=1
当前线程：thread1,i=2

通过上述代码运行结果发现，如果没有设置线程名字，则会自动分配一个线程名字，需要注意的是，线程名如果要设置应避免重复，同时中间不要修改。

public class Test{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.run();//通过对象调用run()方法
        new Thread(myThread).start();//通过线程调用

    }
}

其实，主方法本身就是一个线程，所有的线程都是通过主线程创建并启动的。

2 线程休眠（sleep方法）

线程暂缓执行，等到了预计时间后之后再恢复执行。

线程休眠会交出CPU，让CPU去执行其他任务.

sleep方法不会释放锁，如果当前线程持有对某个对象的锁，则即使调用sleep方法，其他线程也无法访问这个对象。

public static native void sleep(long millis) throws InterruptedException

休眠时间以毫秒作为单位。

调用sleep方法后，先使线程进入阻塞状态，再返回就绪状态。

3 线程让步(yield()方法)

暂停当前正在执行的线程对象，并执行其他进程。

调用yield方法会让当前进程交出CPU权限，让CPU去执行其他线程。跟sleep方法类似，同样不会释放锁。yield不能控制具体的交出CPU的时间，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会

调用yield方法不会让线程进入阻塞状态，而是让线程重回就绪状态，只需等待重新获取CPU的时间。

什么时候使用sleep，什么时候使用yield？

等资源就位时使用sleep，没有强业务关联使用yield

4 join()方法

等待该线程终止。如果在主线程中调用该方法时就会让主线程休眠，让调用该方法的run()方法先执行完毕后再开始执行主线程。

5 线程停止

设置标记位，可以是线程正常退出
使用Thread类中的一个interrupt()可以中断线程。

class MyThread implements Runnable{
    private volatile boolean flag = true;

    @Override
    public void run() {
        int i = 1;
        while(flag){
            try {
                Thread.sleep(2000);
                System.out.println("第"+i+"次执行，线程名称为:"+Thread.currentThread().getName());
                i++;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public void setFlag(boolean flag){
        this.flag = flag;
    }
}
public class Test{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread1 = new Thread(myThread,"子线程1");
        thread1.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        myThread.setFlag(false);
      
    }
}

使用Thread.interrupt()

class MyThread implements Runnable{
    private boolean flag = true;

    @Override
    public void run() {
        int i = 1;
        while(flag){
            try {
                //阻塞之后，线程调用interrupt()方法；
                Thread.sleep(1000);
                boolean bool = Thread.currentThread().isInterrupted();
                if(bool){
                    System.out.println("非阻塞情况下执行该操作，线程状态:"+bool);
                    break;
                }

                System.out.println("第"+i+"次执行，线程名称为:"+Thread.currentThread().getName());
                i++;
            } catch (InterruptedException e) {
                e.printStackTrace();
                //退出阻塞状态，中断标志被系统自动清除
                boolean bool = Thread.currentThread().isInterrupted();
                System.out.println(bool);
                return;
            }
        }
    }
    public void setFlag(boolean flag){
        this.flag = flag;
    }
}
public class Test{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread1 = new Thread(myThread,"子线程1");
        thread1.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread1.interrupt();
    }
}

调用线程类的interrupt()方法，本质是设置该线程的中断标志，将中断设为true，并根据线程状态决定是否抛出异常。

6 线程优先级