Java线程详解

半亩方塘立身
137 阅读5分钟

创建线程的几种方式

  • 继承Thread类，可以创建一个继承自Thread类的子类，并重写其run()方法来定义线程的任务。然后通过创建子类的实例并调用start()方法来启动线程。

    class MyThread extends Thread {
    public void run() {
        // 定义线程的任务
    }
}

// 创建并启动线程
MyThread thread = new MyThread();
thread.start();

  • 实现Runnable接口，实现run方法

    class MyRunnable implements Runnable {
    public void run() {
        // 定义线程的任务
    }
}

// 创建并启动线程
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();

  • 通过Callable，需要实现call方法

    class MyCallable implements Callable<Integer> {
    public Integer call() throws Exception {
        // 定义线程的任务
        return 11; // 返回结果
    }
}

  • 通过FutureTask创建

    • FutureTask是Future接口的实现，它实现了一个可以提交给Executor执行的任务，并且可以用来检查任务的执行状态和获取任务的执行结果。
    Callable<Integer> callable = new MyCallable();
FutureTask<Integer> futureTask = new FutureTask<>(callable);

  • 通过线程池（ExecutorService） ExecutorService executor = Executors.newSingleThreadExecutor(); Future future = executor.submit(new MyCallable());

Java线程状态

线程状态有哪些

  1. New（新建状态）： 当线程对象被创建但尚未调用 start() 方法时，线程处于新建状态。
  2. Runnable（可运行状态）： 一旦线程调用了 start() 方法，它就进入了可运行状态。在可运行状态下，线程可能正在执行，也可能正在等待系统资源（如处理器时间片）。
    1. READY（就绪）：线程对象创建后，调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中并分配cpu使用权。
    2. Running（运行状态）： 在可运行状态下，线程可能被线程调度器选择执行，并开始执行线程的 run() 方法。线程进入运行状态后，会根据系统的调度算法分配到处理器上执行。
  3. Blocked（阻塞状态）： 在某些情况下，线程可能会被阻塞，暂停执行。当线程等待某个条件的发生时，它进入了阻塞状态。例如，线程可能因为等待锁、等待输入/输出或等待其他线程的通知而进入阻塞状态。
  4. Waiting（等待状态）： 线程在等待某个特定条件的发生时，会进入等待状态。线程可以通过调用 wait() 方法、join() 方法或者 LockSupport.park() 方法来进入等待状态。
  5. Timed Waiting（计时等待状态）： 类似于等待状态，线程可以通过调用带有超时参数的 Thread.sleep() 方法、Object.wait() 方法或者 Thread.join() 方法来进入计时等待状态。
  6. Terminated（终止状态）： 当线程的 run() 方法执行完毕或者出现未捕获的异常时，线程将进入终止状态。终止状态表示线程已经完成了它的生命周期，并且不再执行。

状态流转如下图所示：

线程状态 (1).jpg

sleep与wait区别

  1. 方法调用位置和锁的释放：

    • sleep()是Thread类的静态方法，可以在任何地方使用。它使当前线程休眠指定的时间，不会释放对象锁。
    • wait()是Object类的方法，只能在同步块或同步方法中使用。它会使当前线程释放对象的锁，并进入等待状态，直到其他线程调用相同对象上的notify()或notifyAll()方法来唤醒等待的线程。

  2. 使用场景：

    • sleep()通常用于模拟线程执行过程中的暂停，定时任务等。它不依赖于对象的锁，因此可以在任何时候使用。
    • wait()通常用于线程间的协调和通信。它必须在同步块或同步方法中使用，以便在等待时释放对象锁，让其他线程能够进入同步块或同步方法进行操作。

  3. 异常处理：

    • sleep()在休眠期间不会被中断，但会抛出InterruptedException异常，可以通过捕获该异常进行处理。
    • wait()在等待期间可以被其他线程调用interrupt()方法中断，会抛出InterruptedException异常。此外，还可以使用wait()方法的重载版本来设置等待超时时间。

  4. 调用方式：

    • sleep()方法直接通过Thread类调用，例如：Thread.sleep(1000);。
    • wait()方法必须通过持有对象的锁调用，例如：synchronized (obj) { obj.wait(); }。

sleep()主要用于控制线程的休眠时间，不释放锁，而wait()主要用于线程间的协调与通信，释放对象的锁。

object.wait()与Objetc.wait(long)区别

Object.wait()和Object.wait(long millis)是Object类中的方法，用于使当前线程进入等待状态，直到其他线程通过调用相同对象的notify()或notifyAll()方法来唤醒等待的线程。它们之间的区别在于等待的方式和超时设置。

  1. Object.wait()

    • wait()方法让当前线程进入无限期等待状态，直到其他线程调用相同对象的notify()或notifyAll()方法来唤醒等待的线程。
    • 调用wait()方法后，当前线程会释放对象的锁，并进入等待队列中，直到被其他线程唤醒。

  2. Object.wait(long millis)

    • wait(long millis)方法让当前线程进入等待状态，最多等待指定的毫秒数，超过指定时间后线程会自动唤醒。
    • 调用wait(long millis)方法后，当前线程会释放对象的锁，并进入等待队列中，直到被其他线程唤醒或超时时间到达。

Thread.sleep()与Thread.sleep(long)区别

在调用Thread.sleep()方法时，有参数和无参数的版本会导致线程的状态稍有不同。

  1. 无参数的Thread.sleep()

    • 无参数版本的Thread.sleep()实际上是调用了带有一个参数的Thread.sleep(long millis)方法，并将参数值设为0，表示休眠0毫秒。
    • 当线程调用无参数的Thread.sleep()时，它会暂停执行一段时间，时间长度由操作系统调度决定。
    • 在这种情况下，线程的状态仍然保持为RUNNABLE，表示线程可执行但未必正在执行，只是暂时停止了执行。

  2. 有参数的Thread.sleep(long millis)

    • 当线程调用有参数的Thread.sleep(long millis)时，它会暂停执行指定的时间，时间长度由传入的参数决定。
    • 在这种情况下，线程的状态也是TIMED_WAITING（定时等待），表示线程正在等待指定的时间，暂时停止了执行。
avatar
文章
阅读
粉丝