java 线程常用方法

最新推荐文章于 2024-03-06 16:38:47 发布

boogie_liu

最新推荐文章于 2024-03-06 16:38:47 发布

阅读量1.2k

点赞数 2

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_45652057/article/details/121922761

版权

1.Tread状态

xx.getState()
Thread具有State内部枚举类型，getState通过调用sun.misc.VM.toThreadState方法来判断当前线程的状态信息。

创建（new）状态: 准备好了一个多线程的对象，即执行了new Thread(); 创建完成后就需要为线程分配内存
就绪（runnable）状态: 调用了start()方法, 等待CPU进行调度
运行（running）状态: 执行run()方法
阻塞（blocked）状态: 暂时停止执行线程，将线程挂起(sleep()、wait()、join()、没有获取到锁都会使线程阻塞), 可能将资源交给其它线程使用
死亡（terminated）状态: 线程销毁(正常执行完毕、发生异常或者被打断interrupt()都会导致线程终止)

public enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    }

在这里插入图片描述

状态转化

1.1.改变线程状态

sleep属于Tread类中的方法，阻塞当前占用CPU的线程，调用sleep方法并不会释放锁（synchronize修饰的代码片段）。
注：
synchronize如果对静态方法加锁，则需要对类加锁而不是对对象加锁，即：synchronize（xx.class）
wait属于基类Object中的方法，调用wait会释放锁。
yield属于Tread方法，不会释放锁，与sleep不同的是，yield不会阻塞线程，让线程进入就绪状态，并让具有相同或更高优先级的线程运行，一旦线程获取到时间片就会开始运行。
join属于是线程对象里的方法，它适用于主线程创建子线程时，当子线程调用join方法时，主线程需要等待子线程执行完成时，才开始运行。（严格来说，join并没有改变当前线程的状态，它改变的是主线程与子线程之间的并发关系，使其串行化运行）

1.2.唤醒线程

调用线程对象里的interrupt()方法会使sleep抛出interruptException异常，从而终止sleep方法，让进程恢复运行。
notify和notifyAll会去通知线程恢复运行
注意wait、notify、notifyAll需要使用在synchronize里，不然一个线程发现线程正在wait，于是调用notify，而此时，另一个线程也发现线程正在wait于是也去调用notify方法。

2.创建线程

2.1. 继承Thread重写run方法

class a extends Thread{
    @Override
    public void run() {
        try {
            System.out.println("override run");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        a a=new a();
        a.start();
    }
}

2.2.实现Runnable接口

class a{
    public static void main(String[] args) {
        Thread t=new Thread(new b());
        t.start();
    }
}

class b implements Runnable {
    @Override
    public void run() {
        System.out.println("implements runnable");
    }
}

不过常用lambda表达式

class a{
    public static void main(String[] args) {
        Thread t=new Thread(()->{
                System.out.println("lambda");
        });
    }
}

2.3.实现callable创建线程

class a{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask=new FutureTask<>(new b());
        Thread t=new Thread(futureTask);
        t.start();
        System.out.println(futureTask.get());

    }
}
class b implements Callable<String> {
    @Override
    public String call() {
        System.out.println("implements callable");
        return "返回数据";
    }
}

Callable是一个泛型接口，传递对象类型，可以通过FutureTask来代理call方法，并且通过调用FutureTask.get()获取线程执行完毕返回的数据对象，（如果线程未执行就调用get方法会发生阻塞），实现callable相对于实现Runnable，callable看以通过FutureTask来获取更详细的线程信息，仔细看FutureTask，它实现RunnableFuture泛型接口

public class FutureTask<V> implements RunnableFuture<V> {}
public interface RunnableFuture<V> extends Runnable, Future<V> {}

注意接口是可以实现多继承。
所以实际上FutureTask实现了Runnable接口的。

2.4.线程池创建线程

为什么使用线程池？
主要是来解决在突然高并发的情况下，对线程创建和销毁的时间消耗，通过线程池，使用已用的线程，从而降低资源的消耗。

线程池的优点：
第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
第三：提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，

j调用ava.util.concurrent.Excecutors中：
newCachedThreadPool()创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool()创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool() 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor() 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

2.4.1.CachedThreadPool

以后完善…未完待续
to be continued

3.用户线程和守护线程

用户线程是确保要完成的线程，而守护线程的销毁同系统的销毁而销毁。
java中可以通过setDaemon()来设置该线程是否为守护线程。

class a{
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            for (int i=0;i<10;i++){
                System.out.println(i+" 用户线程");
            }
        }).start();
        Thread t=new Thread(()->{
            for (int i=0;i<100;i++){
                System.out.println(i+" 守护线程");
            }
        });
        t.setDaemon(true);
        t.start();
//        ExecutorService executorService=Executors.newCachedThreadPool();
    }
}