Java中线程的基本方法使用技巧

1. 线程的创建

Java语言支持线程的创建，常用的线程创建方式有两种：继承Thread类与实现Runnable接口。

1.1 继承Thread类

继承Thread类是一种比较直接的方式，只需要重写Thread类的run()方法即可实现线程的创建。

class MyThread extends Thread {
    public void run() {
        // 线程需要执行的代码
    }
}

// 创建线程
MyThread myThread = new MyThread();
myThread.start();

1.2 实现Runnable接口

Runnable接口只有一个run()方法，通过实现这个接口通常比继承Thread类更为灵活。

class MyRunnable implements Runnable{
    public void run(){
        // 线程需要执行的代码
    }
}

// 创建线程
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();

2. 线程的同步

在多线程编程中，数据共享会导致线程安全问题，为了避免这类问题，我们可以使用线程同步机制。

2.1 synchronized关键字

synchronized关键字通常与锁对象一起使用，可以防止多个线程同时执行代码块或方法。

class MyThread extends Thread {
    private int count = 10;

    public void run() {
        synchronized (this) {
            while (count > 0) {
                System.out.println(Thread.currentThread().getName() + " count: " + count--);
            }
        }
    }
}

// 创建线程
MyThread myThread = new MyThread();
myThread.start();

在上面的代码中，使用synchronized关键字锁定了MyThread对象，确保了只有一个线程能够执行该对象的run()方法。

2.2 wait()、notify()与notifyAll()方法

wait()方法会使当前线程等待，同时释放当前线程持有的锁对象，直到其他线程通知它再次获得锁对象。notify()与notifyAll()方法负责通知其他等待该锁对象的线程，可以重新争取获取锁对象。

class MyThread extends Thread {
    private Object lock = new Object();

    public void run() {
        synchronized (lock) {
            try {
                System.out.println(Thread.currentThread().getName() + " start");
                lock.wait(); // 线程等待，释放锁对象
                System.out.println(Thread.currentThread().getName() + " end");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 创建线程
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();

myThread1.start();
myThread2.start();

// 主线程通知其它线程
Thread.sleep(1000);
synchronized (myThread1.lock) {
    myThread1.lock.notify(); // 通知一个线程
}
synchronized (myThread2.lock) {
    myThread2.lock.notifyAll(); // 通知所有线程
}

在上面的代码中，使用了Object类的wait()、notify()与notifyAll()方法进行线程同步。

3. 线程的状态控制

线程的状态包括：新建、就绪、运行、阻塞与死亡。线程的状态控制可以使类更加灵活地使用线程。

3.1 sleep()方法

sleep()方法可以使线程进入休眠状态，从而达到控制线程状态的目的。

class MyThread extends Thread {
    public void run() {
        try {
            System.out.println(Thread.currentThread().getName() + " start");
            Thread.sleep(2000); // 线程休眠2秒
            System.out.println(Thread.currentThread().getName() + " end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// 创建线程
MyThread myThread = new MyThread();
myThread.start();

3.2 join()方法

join()方法可以使一个线程等待另一个线程完成后再执行。

class MyThread extends Thread {
    public void run() {
        try {
            System.out.println(Thread.currentThread().getName() + " start");
            Thread.sleep(2000); // 线程休眠2秒
            System.out.println(Thread.currentThread().getName() + " end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// 创建线程
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();

myThread1.start();
myThread2.start();

try {
    myThread1.join(); // 等待myThread1执行完成后再执行
} catch (InterruptedException e) {
    e.printStackTrace();
}

在上面的代码中，使用了join()方法等待myThread1执行完成后才执行myThread2。

结论

以上介绍了Java中线程的基本方法使用技巧，包括线程的创建、线程的同步、线程的状态控制等。在实际编程中，需要根据具体需求来选择合适的线程控制方法，从而实现高效的多线程编程。

阅读剩余 72%