Java创建线程

一、线程概述

线程是操作系统能够进行运算调度的最小单位，它被包含于进程中，与同一进程中的其他线程共享进程的内存和其他资源，是并发编程的重要概念。

Java 中的每个线程都是一个线程对象，都实现了 Runnable 接口中的 run() 方法。线程的创建、启动和运行将分别介绍如下。

二、创建线程的三种方式

1. 继承 Thread 类

通过继承 Thread 类来创建线程，需要重写 run() 方法并在其中定义线程代码。然后创建该类对象并调用 start() 方法启动线程。

class MyThread extends Thread {
    public void run() {
        // 线程代码
    }
}
MyThread myThread = new MyThread();
myThread.start();

2. 实现 Runnable 接口

通过实现 Runnable 接口来创建线程，同样需要实现 run() 方法，并在其中定义线程代码。然后创建 Thread 类对象并把 Runnable 对象作为构造方法的参数传入，然后调用 start() 方法启动线程。

class MyRunnable implements Runnable {
    public void run() {
        // 线程代码
    }
}
MyRunnable myRunnable = new MyRunnable();
Thread myThread = new Thread(myRunnable);
myThread.start();

3. 实现 Callable 接口

Callable 接口通过 call() 方法使得线程可以返回执行结果，并且可以通过 Future 接口获取线程返回结果。

class MyCallable implements Callable {
    public String call() throws Exception {
        // 线程代码
        return "线程执行结果";
    }
}
MyCallable myCallable = new MyCallable();
FutureTask
    result = new FutureTask<>(myCallable);
Thread myThread = new Thread(result);
myThread.start();
String threadResult = result.get(); // 获取线程执行结果

   
  

三、线程的常用方法

1. sleep()

sleep() 方法使当前线程暂停指定的时间（毫秒），通过该方法可以实现线程的延迟执行。

try {
    Thread.sleep(1000); // 线程睡眠 1 秒
} catch (InterruptedException e) {
    e.printStackTrace();
}

2. join()

join() 方法使当前线程等待另一个线程结束，通过该方法可以控制线程的执行顺序。

Thread myThread = new Thread(new MyRunnable());
myThread.start();
try {
    myThread.join(); // 等待 myThread 线程执行结束
} catch (InterruptedException e) {
    e.printStackTrace();
}

3. yield()

yield() 方法使当前线程让出 CPU 控制权，暂停当前线程并使其它线程有机会继续执行。

Thread.yield();

4. setPriority()

setPriority() 方法设置线程的优先级，优先级高的线程被系统调度的概率更高。

Thread myThread = new Thread(new MyRunnable());
myThread.setPriority(Thread.MAX_PRIORITY); // 将 myThread 线程优先级设置为最高
myThread.start();

5. interrupt()

interrupt() 方法中断线程运行，抛出 InterruptedException 异常。

Thread myThread = new Thread(new MyRunnable());
myThread.start();
myThread.interrupt(); // 中断 myThread 线程运行

四、线程的同步控制

1. synchronized

synchronized 关键字可以实现线程的同步控制，通过 synchronized 关键字给代码段加锁，使得多个线程不能同时执行同一个代码段。

class SyncDemo {
    synchronized void printNum() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
SyncDemo syncDemo = new SyncDemo();
Thread thread1 = new Thread(() -> syncDemo.printNum());
Thread thread2 = new Thread(() -> syncDemo.printNum());
thread1.start();
thread2.start();

2. lock

Lock 接口是从 JDK5 引入的一种新的同步机制，它提供与 synchronized 关键字相同的同步功能，但相比 synchronized 关键字更灵活、更安全、性能更优。

Lock lock = new ReentrantLock();
class LockDemo {
    void printNum() {
        lock.lock();
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        lock.unlock();
    }
}
LockDemo lockDemo = new LockDemo();
Thread thread1 = new Thread(() -> lockDemo.printNum());
Thread thread2 = new Thread(() -> lockDemo.printNum());
thread1.start();
thread2.start();

五、总结

本文从线程概述、创建线程的三种方式、线程的常用方法、线程的同步控制四个方面详细介绍了 Java 创建线程的相关知识点，并给出了代码实现。掌握了本文所讲的知识点，才能更好地进行 Java 并发编程。