文章目录
- 1. start()：启动线程，使其执行run()方法中的代码。
- 2. run()：线程的执行逻辑，需要在该方法中定义线程要执行的代码。
- 3. sleep(long millis)：使当前线程暂停指定的毫秒数，进入阻塞状态。
- 4. join()：等待线程执行完毕，即阻塞当前线程，直到该线程执行完成。
- 5. interrupt()：中断线程，给线程发送中断信号。
- 6. isInterrupted()：判断当前线程是否被中断。
- 7. getName()：获取线程的名称。
- 8. setName(String name)：设置线程的名称。
- 9. isAlive()：判断线程是否还存活，即线程是否执行完毕或被中断。
- 10. yield()：暂停当前正在执行的线程，并允许其他线程执行。
- 11. setPriority(int priority)：设置线程的优先级。
- 12. getPriority()：获取线程的优先级。
1. start()：启动线程，使其执行run()方法中的代码。
start()方法用于启动一个线程，使其执行run()方法中的代码。start()方法会创建一个新的线程，并使其进入就绪状态，等待调度执行。
下面是一个简单的示例，演示了如何使用start()方法启动一个线程：
public class MyThread extends Thread {
public void run() {
System.out.println("Thread running");
}
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
}
}
在上面的示例中，我们定义了一个继承自Thread类的MyThread类，重写了run()方法，在run()方法中输出一句话。在main()方法中，我们创建了一个MyThread对象，并使用start()方法启动了该线程。当程序运行时，会创建一个新的线程，并执行MyThread类中的run()方法，输出"Thread running"。
需要注意的是，start()方法只能在一个线程中被调用一次。如果我们尝试多次调用start()方法，会抛出IllegalThreadStateException异常。另外，start()方法会在内部自动调用run()方法，我们不应该直接调用run()方法来启动一个线程，而应该使用start()方法来启动线程。
2. run()：线程的执行逻辑，需要在该方法中定义线程要执行的代码。
run()方法是Thread类中定义的线程执行逻辑的方法。当一个线程通过start()方法启动后，会自动调用run()方法来执行线程的代码逻辑。
下面是一个简单的示例，演示了如何使用run()方法定义线程的执行逻辑：
public class MyThread implements Runnable {
public void run() {
System.out.println("Thread running");
}
public static void main(String[] args) {
MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);
thread.start();
}
}
在上面的示例中，我们定义了一个实现了Runnable接口的MyThread类，重写了run()方法，在run()方法中输出一句话。在main()方法中，我们创建了一个Thread对象，并将MyThread对象作为参数传递给Thread的构造函数。然后，我们通过start()方法启动了该线程。当程序运行时，会创建一个新的线程，并执行MyThread类中的run()方法，输出"Thread running"。
需要注意的是，Runnable接口是实现多线程的另一种方式，相比于直接继承Thread类，使用Runnable接口更加灵活，因为Java中不支持多重继承，而实现接口可以避免这个限制。另外，使用Runnable接口实现多线程时，需要将实现了Runnable接口的对象作为参数传递给Thread的构造函数，然后通过Thread对象来启动线程。
3. sleep(long millis)：使当前线程暂停指定的毫秒数，进入阻塞状态。
sleep(long millis)是Thread类中的一个静态方法，用于使当前线程进入休眠状态指定的时间。
下面是一个简单的示例，演示了如何使用sleep()方法使线程休眠：
public class SleepDemo {
public static void main(String[] args) {
System.out.println("Thread 1 running");
try {
Thread.sleep(2000); // 使当前线程休眠2秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 1 resumed");
System.out.println("Thread 2 running");
try {
Thread.sleep(3000); // 使当前线程休眠3秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 2 resumed");
System.out.println("Main thread finished");
}
}
在上面的示例中，我们通过调用Thread.sleep()方法使当前线程休眠了一段时间。在第一次调用Thread.sleep(2000)后，当前线程会暂停执行2秒钟，然后继续执行下面的代码。在第二次调用Thread.sleep(3000)后，当前线程会再次暂停执行3秒钟，然后继续执行下面的代码。
需要注意的是，Thread.sleep()方法可能会抛出InterruptedException异常，这是因为当线程处于休眠状态时，其他线程可以通过调用该线程的interrupt()方法来中断它的休眠，从而抛出InterruptedException异常。因此，在使用Thread.sleep()方法时，需要处理这个异常。
另外，需要注意的是，Thread.sleep()方法是静态方法，所以可以直接通过类名来调用，不需要实例化线程对象。
4. join()：等待线程执行完毕，即阻塞当前线程，直到该线程执行完成。
join()方法是Thread类中的一个实例方法，用于等待当前线程执行完毕。
下面是一个简单的示例，演示了如何使用join()方法等待其他线程执行完毕：
public class JoinDemo {
public static void main(String[] args) {
Thread thread1 = new Thread(new MyRunnable(), "Thread 1");
Thread thread2 = new Thread(new MyRunnable(), "Thread 2");
thread1.start();
thread2.start();
try {
thread1.join(); // 等待Thread 1执行完毕
thread2.join(); // 等待Thread 2执行完毕
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Main thread finished");
}
static class MyRunnable implements Runnable {
@Override
public void run() {
String threadName = Thread.currentThread().getName();
System.out.println(threadName + " running");
try {
Thread.sleep(2000); // 模拟线程执行时间
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(threadName + " finished");
}
}
}
在上面的示例中，我们创建了两个线程thread1和thread2，并通过调用start()方法启动它们。然后，使用join()方法在主线程中等待thread1和thread2执行完毕。
使用join()方法的效果是，主线程会暂停执行，直到thread1和thread2执行完毕之后才会继续执行下面的代码。这样可以保证在主线程继续执行之前，thread1和thread2已经执行完毕。
需要注意的是，join()方法也可能会抛出InterruptedException异常，因此需要进行异常处理。
另外，需要注意的是，join()方法是实例方法，所以需要通过线程对象来调用。在示例中，我们创建了两个线程对象thread1和thread2，并通过调用它们的join()方法来等待它们的执行完毕。
5. interrupt()：中断线程，给线程发送中断信号。
interrupt()方法是Thread类中的一个实例方法，用于中断线程的执行。
下面是一个简单的示例，演示了如何使用interrupt()方法中断线程的执行：
public class InterruptDemo {
public static void main(String[] args) {
Thread thread = new Thread(new MyRunnable(), "MyThread");
thread.start();
try {
Thread.sleep(2000); // 主线程睡眠2秒钟
} catch (InterruptedException e) {
e.printStackTrace();
}
thread.interrupt(); // 中断线程的执行
}
static class MyRunnable implements Runnable {
@Override
public void run() {
while (!Thread.currentThread().isInterrupted()) {
System.out.println("Thread running");
try {
Thread.sleep(500); // 线程睡眠500毫秒
} catch (InterruptedException e) {
System.out.println("Thread interrupted");
Thread.currentThread().interrupt(); // 重新设置中断标志位
}
}
System.out.println("Thread finished");
}
}
}
在上面的示例中，我们创建了一个线程thread，并通过调用start()方法启动它。然后，主线程睡眠2秒钟后，调用thread的interrupt()方法来中断线程的执行。
在线程的run()方法中，我们使用了一个while循环来检查线程的中断状态。只要线程没有被中断，就会一直执行循环中的代码。在循环中，我们打印一条信息并让线程睡眠500毫秒。
当线程被中断时，会抛出InterruptedException异常。在异常处理代码中，我们打印一条中断信息，并通过调用Thread.currentThread().interrupt()方法重新设置线程的中断标志位，以便在下一次循环时能够检测到线程被中断。
当线程检测到中断状态时，会退出循环并打印一条线程结束的信息。
需要注意的是，interrupt()方法只是设置线程的中断标志位，实际上并不会强制停止线程的执行。在线程的代码中需要通过检查中断状态来决定是否继续执行。
6. isInterrupted()：判断当前线程是否被中断。
isInterrupted()方法是Thread类中的一个实例方法，用于判断线程是否被中断。
下面是一个简单的示例，演示了如何使用isInterrupted()方法来判断线程是否被中断：
public class IsInterruptedDemo {
public static void main(String[] args) {
Thread thread = new MyThread();
thread.start();
try {
Thread.sleep(2000); // 主线程睡眠2秒钟
} catch (InterruptedException e) {
e.printStackTrace();
}
thread.interrupt(); // 中断线程的执行
}
static class MyThread extends Thread {
@Override
public void run() {
while (!isInterrupted()) {
System.out.println("Thread running");
try {
Thread.sleep(500); // 线程睡眠500毫秒
} catch (InterruptedException e) {
System.out.println("Thread interrupted");
interrupt(); // 重新设置中断标志位
}
}
System.out.println("Thread finished");
}
}
}
在上面的示例中，我们创建了一个继承自Thread类的MyThread类，并重写了其run()方法。在run()方法中，我们使用了一个while循环来检查线程的中断状态。只要线程没有被中断，就会一直执行循环中的代码。在循环中，我们打印一条信息并让线程睡眠500毫秒。
当线程被中断时，会抛出InterruptedException异常。在异常处理代码中，我们打印一条中断信息，并通过调用interrupt()方法重新设置线程的中断标志位，以便在下一次循环时能够检测到线程被中断。
使用isInterrupted()方法可以在任何地方判断线程是否被中断。在本例中，我们在循环条件中使用isInterrupted()方法来判断线程是否被中断，如果被中断则跳出循环。
需要注意的是，isInterrupted()方法只是返回线程的中断状态，并不会清除中断标志位。因此，在重新设置中断标志位时，需要调用interrupt()方法。
7. getName()：获取线程的名称。
getName()方法是Thread类中的一个实例方法，用于获取线程的名称。
下面是一个简单的示例，演示了如何使用getName()方法来获取线程的名称：
public class GetNameDemo {
public static void main(String[] args) {
Thread thread1 = new MyThread("Thread 1");
Thread thread2 = new MyThread("Thread 2");
thread1.start();
thread2.start();
}
static class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
@Override
public void run() {
System.out.println("Thread name: " + getName());
}
}
}
8. setName(String name)：设置线程的名称。
getName()方法是Thread类中的一个实例方法，用于获取线程的名称。
下面是一个简单的示例，演示了如何使用getName()方法来获取线程的名称：
public class GetNameDemo {
public static void main(String[] args) {
Thread thread1 = new MyThread("Thread 1");
Thread thread2 = new MyThread("Thread 2");
thread1.start();
thread2.start();
}
static class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
@Override
public void run() {
System.out.println("Thread name: " + getName());
}
}
}
在上面的示例中，我们创建了一个继承自Thread类的MyThread类，并在构造方法中传入线程的名称。在run()方法中，我们使用getName()方法来获取线程的名称，并打印出来。
在main()方法中，我们创建了两个MyThread对象，并分别给它们指定了不同的名称。然后，我们调用start()方法启动这两个线程。
运行该示例，会输出如下结果：
Thread name: Thread 1
Thread name: Thread 2
可以看到，每个线程都成功获取到了自己的名称并打印出来。
通过getName()方法，我们可以在任何需要的地方获取到线程的名称。这在多线程编程中非常有用，可以帮助我们区分和识别不同的线程。
9. isAlive()：判断线程是否还存活，即线程是否执行完毕或被中断。
isAlive()方法是Thread类中的一个实例方法，用于判断线程是否处于活动状态。
下面是一个简单的示例，演示了如何使用isAlive()方法来判断线程是否处于活动状态：
public class IsAliveDemo {
public static void main(String[] args) {
Thread thread1 = new MyThread("Thread 1");
Thread thread2 = new MyThread("Thread 2");
thread1.start();
thread2.start();
System.out.println("Thread 1 is alive: " + thread1.isAlive());
System.out.println("Thread 2 is alive: " + thread2.isAlive());
}
static class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
@Override
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
在上面的示例中，我们创建了一个继承自Thread类的MyThread类，并在构造方法中传入线程的名称。在run()方法中，我们让线程休眠2秒钟，模拟一些工作。
在main()方法中，我们创建了两个MyThread对象，并分别给它们指定了不同的名称。然后，我们调用start()方法启动这两个线程。
接着，我们使用isAlive()方法来判断线程是否处于活动状态，并将结果打印出来。
运行该示例，会输出如下结果：
Thread 1 is alive: true
Thread 2 is alive: true
可以看到，尽管我们在main()方法中立即调用了isAlive()方法，但由于线程休眠了2秒钟，所以两个线程仍然处于活动状态，isAlive()方法返回的结果都为true。
通过isAlive()方法，我们可以在需要时判断线程是否处于活动状态，以便进行相应的处理。
10. yield()：暂停当前正在执行的线程，并允许其他线程执行。
yield()方法是Thread类中的一个静态方法，用于让出CPU资源，让其他线程有机会执行。
下面是一个简单的示例，演示了如何使用yield()方法来让出CPU资源
public class YieldDemo {
public static void main(String[] args) {
Thread thread1 = new MyThread("Thread 1");
Thread thread2 = new MyThread("Thread 2");
thread1.start();
thread2.start();
}
static class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(getName() + ": " + i);
Thread.yield();
}
}
}
}
在上面的示例中，我们创建了一个继承自Thread类的MyThread类，并在构造方法中传入线程的名称。在run()方法中，我们使用一个简单的循环来输出线程的名称和计数。
在每次循环中，我们调用Thread.yield()方法，让出CPU资源给其他线程。这样，其他线程有机会执行。
运行该示例，会输出如下结果：
Thread 1: 0
Thread 2: 0
Thread 1: 1
Thread 2: 1
Thread 1: 2
Thread 2: 2
Thread 1: 3
Thread 2: 3
Thread 1: 4
Thread 2: 4
可以看到，两个线程轮流输出，通过使用yield()方法，我们可以让线程有机会让出CPU资源，从而实现线程之间的交替执行。
需要注意的是，yield()方法只是一个建议性的方法，它不能保证一定让出CPU资源，具体是否让出由操作系统决定。因此，yield()方法只应该在特定的情况下使用，例如在多个线程执行相同任务时，可以使用yield()方法来平衡线程的执行。
11. setPriority(int priority)：设置线程的优先级。
setPriority(int priority)方法是Thread类中的一个方法，用于设置线程的优先级。线程的优先级决定了线程在竞争CPU资源时的相对执行顺序。
下面是一个简单的示例，演示了如何使用setPriority()方法来设置线程的优先级：
public class PriorityDemo {
public static void main(String[] args) {
Thread thread1 = new MyThread("Thread 1");
Thread thread2 = new MyThread("Thread 2");
thread1.setPriority(Thread.MIN_PRIORITY);
thread2.setPriority(Thread.MAX_PRIORITY);
thread1.start();
thread2.start();
}
static class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(getName() + ": " + i);
}
}
}
}
在上面的示例中，我们创建了一个继承自Thread类的MyThread类，并在构造方法中传入线程的名称。在run()方法中，我们使用一个简单的循环来输出线程的名称和计数。
在main()方法中，我们创建了两个线程对象thread1和thread2，并分别使用setPriority()方法设置它们的优先级。其中，thread1的优先级被设置为最低优先级(Thread.MIN_PRIORITY)，而thread2的优先级被设置为最高优先级(Thread.MAX_PRIORITY)。
然后，我们调用start()方法启动线程。
运行该示例，会输出如下结果：
Thread 2: 0
Thread 2: 1
Thread 2: 2
Thread 2: 3
Thread 2: 4
Thread 1: 0
Thread 1: 1
Thread 1: 2
Thread 1: 3
Thread 1: 4
可以看到，由于线程thread2的优先级被设置为最高，它先于线程thread1执行。然后，线程thread1执行。
需要注意的是，线程的优先级只是一个建议性的概念，它不能保证线程的执行顺序。具体的线程调度由操作系统决定。因此，设置线程的优先级应该谨慎，并且只在特定的情况下使用。
12. getPriority()：获取线程的优先级。
getPriority()方法是Thread类中的一个方法，用于获取线程的优先级。可以通过调用该方法来获取线程当前的优先级。
下面是一个简单的示例，演示了如何使用getPriority()方法来获取线程的优先级：
public class PriorityDemo {
public static void main(String[] args) {
Thread thread1 = new MyThread("Thread 1");
Thread thread2 = new MyThread("Thread 2");
thread1.setPriority(Thread.MIN_PRIORITY);
thread2.setPriority(Thread.MAX_PRIORITY);
System.out.println(thread1.getName() + " priority: " + thread1.getPriority());
System.out.println(thread2.getName() + " priority: " + thread2.getPriority());
}
static class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(getName() + ": " + i);
}
}
}
}
在上面的示例中，我们创建了一个继承自Thread类的MyThread类，并在构造方法中传入线程的名称。在run()方法中，我们使用一个简单的循环来输出线程的名称和计数。
在main()方法中，我们创建了两个线程对象thread1和thread2，并分别使用setPriority()方法设置它们的优先级。然后，我们调用getPriority()方法分别获取线程thread1和thread2的优先级，并输出结果。
运行该示例，会输出如下结果：
Thread 1 priority: 1
Thread 2 priority: 10
可以看到，线程thread1的优先级为1，而线程thread2的优先级为10。
需要注意的是，线程的优先级只是一个建议性的概念，具体的线程调度由操作系统决定。因此，获取线程的优先级只是为了了解当前线程的优先级，并不能保证线程的执行顺序。
