多线程的常见成员方法

 

1.在Java多线程编程中，Thread类提供了一个方法叫做getName()，用于获取线程的名称。

public class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running");
        System.out.println("Thread name: " + getName());
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

在上述代码中，我们创建了一个自定义的线程类MyThread，继承自Thread类。在run()方法中，打印线程正在运行的消息，并通过调用getName()方法获取线程的名称，并打印输出。

在main方法中，我们创建了一个MyThread对象，并调用start()方法启动线程。在线程运行时，会输出线程的名称。

使用getName()方法可以获取当前线程的名称，通常用于日志记录或调试目的。每个线程都有一个唯一的名称，可以更好地区分和追踪不同的线程执行情况。

2.在Java多线程编程中，Thread类提供了一个方法叫做setName()，用于设置线程的名称。

public class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running");
        System.out.println("Thread name: " + getName());
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.setName("MyThread");
        thread.start();
    }
}

在上述代码中，我们创建了一个自定义的线程类MyThread，继承自Thread类。在run()方法中，打印线程正在运行的消息，并通过调用getName()方法获取线程的名称，并打印输出。

在main方法中，我们创建了一个MyThread对象，并调用setName()方法设置线程的名称为"MyThread"。然后，调用start()方法启动线程。

需要注意的是，如果没有显式地设置线程的名称，系统会为线程分配一个默认的名称，如"Thread-0"、"Thread-1"等。如果需要自定义线程的名称，可以通过调用Thread类的setName()方法来设置。

使用setName()方法可以设置当前线程的名称，通常用于标识线程的作用或用途。设置线程名称可以方便调试和日志记录，使得可以更好地区分和追踪不同线程的执行情况。当然，需要注意避免线程名的重复，以保证唯一性和清晰性。

3.在Java多线程编程中，Thread类提供了一个静态方法叫做currentThread()，用于获取当前正在执行的线程对象。

public class MyThread implements Runnable {
    public void run() {
        Thread currentThread = Thread.currentThread();
        System.out.println("Current thread: " + currentThread.getName());
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread = new Thread(myThread);
        thread.start();
    }
}

在上述代码中，我们实现了Runnable接口，并重写了run()方法。在run()方法中，我们调用Thread类的currentThread()方法获取当前线程对象，并通过getName()方法获取线程的名称。

在main方法中，我们创建了一个MyThread对象，并将其作为参数传递给Thread类的构造函数来创建一个线程对象。然后，调用start()方法启动线程。

运行程序时，当前线程对象会通过currentThread()方法获取，并打印输出线程的名称。

需要注意的是，currentThread()方法是Thread类的静态方法，可以直接通过类名调用。它返回的是一个Thread对象，代表当前正在执行的线程。

使用currentThread()方法可以获取当前线程的引用，可以用于获取线程的相关信息，例如线程的名称、优先级等。这对于在线程的执行过程中需要根据当前线程进行某些操作或判断时非常有用。

4.在Java多线程编程中，Thread类提供了一个静态方法叫做sleep()，用于使当前线程暂停执行一段时间。

sleep()方法有两种重载形式：

• sleep(long millis)：使当前线程暂停指定的毫秒数。
• sleep(long millis, int nanos)：使当前线程暂停指定的毫秒数和纳秒数

public class SleepExample {
    public static void main(String[] args) {
        System.out.println("Start");

        try {
            Thread.sleep(2000); // 暂停2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("End");
    }
}

 

在上述代码中，我们使用sleep()方法使当前线程暂停2秒钟。在try-catch块中，我们捕获了InterruptedException异常，该异常在其他线程中调用interrupt()方法中断了当前线程的睡眠时会被抛出。

运行程序时，输出"Start"后会暂停2秒钟，然后输出"End"。

sleep()方法的作用是暂停当前线程的执行一段时间，让出CPU资源给其他线程。在暂停期间，线程处于阻塞状态，不会执行任何操作。

sleep()方法常用于模拟耗时操作，或者需要让线程等待一段时间后再执行下一步操作的情况。

需要注意的是，sleep()方法可能会抛出InterruptedException异常，因此需要捕获并处理该异常。如果在睡眠期间，其他线程调用了当前线程的interrupt()方法中断了其睡眠，sleep()方法会立即抛出InterruptedException异常。

5.在Java多线程编程中，Thread类提供了一个方法叫做setPriority()，用于设置线程的优先级。

优先级（Priority）是多线程编程中用于指定线程调度顺序的一个属性。每个线程都有一个优先级，优先级较高的线程在竞争CPU资源时有更大的概率被选择执行。

Java中的线程优先级由整数表示，范围从1到10，默认优先级为5。可以使用Thread类的setPriority()方法设置线程的优先级，也可以使用getPriority()方法获取线程的优先级。

Java线程优先级的具体调度行为依赖于操作系统和虚拟机的实现。在大多数情况下，较高优先级的线程会比较低优先级的线程更频繁地获得执行时间片。然而，无法保证高优先级的线程一定比低优先级的线程先执行或者执行更长的时间。

setPriority()方法有以下几个常量可以用作参数：

• Thread.MIN_PRIORITY：表示最低优先级，具有较低的调度权重。
• Thread.NORM_PRIORITY：表示默认优先级，具有普通的调度权重。
• Thread.MAX_PRIORITY：表示最高优先级，具有较高的调度权重。

需要注意以下几点：

• 不同操作系统对于线程优先级的处理方式可能不同，因此在跨平台开发时不能太过依赖线程优先级。
• 在大部分情况下，只有明显的差异才会对线程优先级产生影响，例如将一个线程的优先级设置为最高或最低。
• 线程优先级并不能保证绝对的执行顺序，仅仅是增加了线程被调度的几率。

 

public class PriorityExample extends Thread {
    public void run() {
        System.out.println("Thread name: " + getName());
    }

    public static void main(String[] args) {
        PriorityExample thread1 = new PriorityExample();
        PriorityExample thread2 = new PriorityExample();

        thread1.setPriority(Thread.MIN_PRIORITY); // 设置thread1的优先级为最低
        thread2.setPriority(Thread.MAX_PRIORITY); // 设置thread2的优先级为最高

        thread1.start();
        thread2.start();
    }
}

 

在上述代码中，我们创建了两个PriorityExample对象作为线程实例。通过调用setPriority()方法，我们分别将thread1的优先级设置为最低（MIN_PRIORITY）和thread2的优先级设置为最高（MAX_PRIORITY）。

在run()方法中，我们打印当前线程的名称。

在main方法中，我们启动了thread1和thread2两个线程。

需要注意的是，线程的优先级设置并不一定会准确反映在操作系统的线程调度中。具体的线程调度行为取决于操作系统和虚拟机的实现。尽管如此，通过设置优先级可以一定程度上影响线程的调度顺序。

优先级较高的线程有更大的概率比优先级较低的线程优先获得CPU资源。然而，应该谨慎使用线程优先级来控制程序的逻辑，因为过度依赖线程优先级可能导致不可预测的结果，而且可能会降低可移植性。

6.getPriority()是Java中Thread类的一个方法，用于获取线程的优先级。它返回一个整数值，表示当前线程的优先级。

public class PriorityExample extends Thread {
    public void run() {
        int priority = getPriority(); // 获取当前线程的优先级
        System.out.println("Thread priority: " + priority);
    }

    public static void main(String[] args) {
        PriorityExample thread = new PriorityExample();
        thread.start();
    }
}

 

在上述代码中，我们创建了一个PriorityExample对象作为线程实例，并通过start()方法启动线程。

在run()方法中，我们使用getPriority()方法获取当前线程的优先级，并将其打印输出。

通过调用getPriority()方法，我们可以获取当前线程的优先级。需要注意的是，如果未显式设置优先级，则线程的优先级默认为创建它的线程的优先级。

7. 

在Java中，守护线程（Daemon Thread）是一种特殊类型的线程，用于为其他非守护线程提供服务。与非守护线程不同，当所有非守护线程结束时，守护线程会自动退出。

守护线程的特点如下：

1. 守护线程通过调用Thread类的setDaemon(true)方法设置为守护线程。默认情况下，线程是非守护线程。
2. 守护线程的作用是为其他线程提供服务，例如垃圾回收、后台任务等。
3. 守护线程通常不处理关键业务逻辑，而是执行一些辅助性工作。
4. 当所有非守护线程都结束时，JVM会自动退出，不会等待守护线程执行完毕。

   public class DaemonThreadExample {
       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();
   
           System.out.println("Main thread ends");
       }
   }
   

   在上述代码中，我们创建了一个守护线程，守护线程会不断输出一条消息。在main()方法中，我们将线程设置为守护线程，并启动它。

   当所有非守护线程执行完毕后，程序会退出，而无需等待守护线程执行完毕。

8.在多线程编程中，线程之间的礼让（Thread Yielding）是一种线程协作的机制，它允许一个正在执行的线程主动暂停，将CPU资源让给其他具有相同或更高优先级的线程。通过礼让线程，我们可以提高线程执行的公平性和效率。

在Java中，线程可以通过调用Thread.yield()方法来进行礼让。当一个线程调用yield()方法时，它会暂停当前的执行，并让出CPU控制权给其他线程。但要注意，yield()方法只是一个暗示，它不能保证其他线程一定会得到执行的机会，取决于系统调度器的实现。

public class ThreadYieldExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Thread 1: " + i);
                Thread.yield(); // 线程1暂停并礼让CPU资源
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Thread 2: " + i);
                Thread.yield(); // 线程2暂停并礼让CPU资源
            }
        });

        thread1.start();
        thread2.start();
    }
}

 

在上述代码中，我们创建了两个线程thread1和thread2，并分别在每个线程的执行过程中调用了Thread.yield()方法。

当运行这段代码时，两个线程会交替执行并输出各自的计数值。通过使用yield()方法，线程会主动暂停一段时间，让出CPU资源给其他线程执行。

需要注意的是，虽然yield()方法可以增加线程执行的公平性，但过度使用或滥用yield()方法可能会降低系统的整体性能。因此，在使用yield()方法时需要谨慎考虑，并根据具体情况评估是否真正需要使用该方法。

7.在Java多线程编程中，join()方法用于等待一个线程的结束。当一个线程在另一个线程上调用join()方法时，调用线程将会被阻塞，直到被调用的线程执行完毕。

join()方法在Java多线程编程中具有以下特点：

1. 阻塞调用线程：当一个线程在另一个线程上调用join()方法时，调用线程会被阻塞，停止执行，直到被调用的线程执行完毕。这种阻塞行为意味着调用线程会等待被调用线程的结束。

2. 等待线程执行完毕：join()方法使得调用线程等待被调用线程的执行完成。当被调用线程执行完毕后，调用线程会从阻塞状态中恢复，并继续执行后续代码逻辑。

3. 立即返回已结束线程：如果被调用的线程已经执行完毕，那么join()方法会立即返回，而不会阻塞调用线程。这意味着如果被调用的线程已经结束，join()方法不会产生任何阻塞效果。

4. 可设置超时参数：join()方法可以带有超时参数，用于指定最长等待的时间。如果超过指定的时间，无论被调用的线程是否执行完毕，join()方法会返回，并允许调用线程继续执行后续逻辑。

public class ThreadJoinExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(2000); // 模拟线程执行一段时间
                System.out.println("Thread execution completed");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        thread.start();

        System.out.println("Main thread is waiting for the completion of the child thread");
        thread.join(); // 等待子线程执行完毕

        System.out.println("Main thread resumes execution");
    }
}

 

在上述代码中，我们创建了一个新线程thread，并在其中模拟了一段执行时间。在main()方法中，我们启动了该线程，并在主线程中调用了thread.join()方法，使主线程等待子线程的执行完成。

当运行这段代码时，主线程会输出一条消息表示正在等待子线程的执行完成。然后，子线程开始执行并睡眠2秒钟，之后输出一条消息。最后，主线程收到子线程执行完毕的信号，继续执行并输出相应的消息。

join()方法必须在调用线程的start()方法之前调用，否则需要抛出IllegalThreadStateException异常