java如何让线程立即执行

Java中让线程立即执行的方法包括：调用start()方法、使用Thread.join()方法、使用ExecutorService、调整线程优先级。其中，最为常用且推荐的方法是调用start()方法，这会启动一个新的线程，并让它开始执行run()方法中定义的任务。

调用start()方法时，Java虚拟机会创建一个新的操作系统级别的线程，并调用其run()方法。与直接调用run()方法不同的是，start()方法并不会阻塞当前线程，而是让新线程并发执行。

一、调用`start()`方法

在Java中，创建并启动一个线程的标准做法是通过调用Thread类的start()方法。这个方法将启动一个新的线程，并调用该线程的run()方法。

1.1 创建线程

要创建一个线程，可以通过继承Thread类或实现Runnable接口。以下是两种常见的方式：

方式一：继承Thread类

public class MyThread extends Thread {
    public void run() {
        // 线程执行的任务
        System.out.println("Thread is running");
    }
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程
    }
}

方式二：实现Runnable接口

public class MyRunnable implements Runnable {
    public void run() {
        // 线程执行的任务
        System.out.println("Runnable is running");
    }
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start(); // 启动线程
    }
}

1.2 `start()`方法的工作原理

调用start()方法时，Java虚拟机会为新线程分配资源，并调用其run()方法。与直接调用run()方法不同，start()方法不会阻塞当前线程，而是使新线程并发执行。

1.3 优点

并发执行：start()方法可以启动一个新的线程，并与当前线程并发执行，充分利用多核处理器的优势。
更高效：相比直接调用run()方法，start()方法能更高效地利用系统资源。

二、使用`Thread.join()`方法

Thread.join()方法可以确保当前线程等待调用join()方法的线程执行完毕后再继续执行。

2.1 示例代码

public class MyThread extends Thread {
    public void run() {
        try {
            Thread.sleep(1000); // 模拟耗时任务
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread is running");
    }
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
        try {
            thread.join(); // 等待线程执行完毕
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Main thread continues");
    }
}

2.2 优点

顺序控制：确保线程按指定顺序执行，避免竞态条件。
同步机制：提供一种简单的同步机制，确保某些任务在特定顺序内完成。

三、使用`ExecutorService`

ExecutorService是Java并发包中的一个框架，可以更方便地管理线程池，并执行并发任务。

3.1 创建线程池

可以使用Executors类创建不同类型的线程池，如固定大小的线程池、缓存线程池等。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecutorExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.execute(() -> {
            System.out.println("Task 1 is running");
        });
        executor.execute(() -> {
            System.out.println("Task 2 is running");
        });
        executor.shutdown();
    }
}

3.2 优点

线程复用：线程池可以复用已创建的线程，避免频繁创建和销毁线程的开销。
任务管理：可以方便地管理并发任务，如提交、取消和监控任务的执行状态。

四、调整线程优先级

Java中的线程优先级可以通过Thread.setPriority(int newPriority)方法来设置。虽然线程优先级不能保证线程立即执行，但可以增加线程获得CPU时间片的机会。

4.1 示例代码

public class PriorityExample {
    public static void main(String[] args) {
        Thread highPriorityThread = new Thread(() -> {
            System.out.println("High priority thread is running");
        });
        highPriorityThread.setPriority(Thread.MAX_PRIORITY);
        Thread lowPriorityThread = new Thread(() -> {
            System.out.println("Low priority thread is running");
        });
        lowPriorityThread.setPriority(Thread.MIN_PRIORITY);
        lowPriorityThread.start();
        highPriorityThread.start();
    }
}

4.2 注意事项

操作系统依赖：线程优先级的实现依赖于底层操作系统，不同操作系统的调度策略可能有所不同。
不保证顺序：线程优先级不能保证线程的执行顺序，仅仅是增加了获得CPU时间片的机会。

五、使用守护线程

守护线程是指在后台运行的线程，通常用于执行一些辅助任务，如垃圾回收。可以通过调用Thread.setDaemon(true)方法将一个线程设置为守护线程。

5.1 示例代码

public class DaemonExample {
    public static void main(String[] args) {
        Thread daemonThread = new Thread(() -> {
            while (true) {
                System.out.println("Daemon thread is running");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        daemonThread.setDaemon(true);
        daemonThread.start();
        try {
            Thread.sleep(3000); // 主线程休眠3秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Main thread ends");
    }
}

5.2 优点

后台任务：守护线程适用于执行一些需要长时间运行的后台任务，如日志记录、垃圾回收等。
自动结束：当所有非守护线程结束时，JVM会自动结束所有守护线程。

六、线程同步和锁机制

在多线程环境中，线程同步和锁机制可以确保多个线程安全地访问共享资源。常用的同步机制包括sychronized关键字、ReentrantLock类等。

6.1 使用`sychronized`关键字

sychronized关键字可以用于方法或代码块，确保同一时刻只有一个线程可以执行被同步的方法或代码块。

public class SynchronizedExample {
    private int counter = 0;
    public synchronized void increment() {
        counter++;
    }
    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Final counter value: " + example.counter);
    }
}

6.2 使用`ReentrantLock`类

ReentrantLock类提供了更灵活的锁机制，可以显式地加锁和解锁，并支持公平锁和非公平锁。

import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockExample {
    private int counter = 0;
    private final ReentrantLock lock = new ReentrantLock();
    public void increment() {
        lock.lock();
        try {
            counter++;
        } finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Final counter value: " + example.counter);
    }
}

七、总结

在Java中，让线程立即执行的方法多种多样，选择合适的方法取决于具体的应用场景和需求。通过调用start()方法、使用Thread.join()方法、ExecutorService、调整线程优先级、使用守护线程以及线程同步和锁机制，可以实现不同的并发和同步需求，从而提高应用程序的性能和可靠性。