Java多线程编程基础

Java多线程编程是Java语言的一个重要特性，它允许程序在同一时间执行多个线程，使得程序效率得到了极大提高。本文将介绍Java多线程编程的基础知识，包括线程的基本概念、创建线程的方法、线程同步、线程通信等内容。

一、线程的基本概念

线程是操作系统能够进行运算调度的最小单位，它是程序中的一个独立执行流程。Java语言中线程的实现是通过Thread类来完成的。在Java中，每个程序都运行在一个独立的线程中，这个线程叫作主线程。主线程可以创建多个子线程，每个子线程是独立的运行单元。 线程的状态可以分为五个：新建状态、就绪状态、运行状态、阻塞状态和死亡状态。其中，新建状态指的是线程被创建但还没有开始运行；就绪状态指的是线程准备好被运行；运行状态指的是正在运行的线程；阻塞状态指的是线程在执行时被暂停；死亡状态指的是线程执行完成或者异常终止。

二、创建线程的方法

Java中创建线程主要有两种方法：继承Thread类和实现Runnable接口。

1、继承Thread类

继承Thread类必须重写run()方法，因为run()方法是线程的入口，当线程被调用start()方法之后就会执行run()方法。

public class MyThread extends Thread {
    @Override
    public void run() {
        // 线程逻辑代码
    }
}

创建线程的方式如下：

MyThread myThread = new MyThread();
myThread.start();

2、实现Runnable接口

实现Runnable接口必须实现run()方法，创建Thread对象时将Runnable对象作为参数传入。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程逻辑代码
    }
}

MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();

三、线程同步

线程同步是指多个线程在同一时刻访问共享资源时，保证数据正确性的机制。Java中线程同步的实现有三种方式：synchronized关键字、Lock接口和volatile关键字。

1、synchronized关键字

synchronized关键字可以用来修饰方法或代码块，实现对共享资源的同步控制。当一个线程执行synchronized代码块时，其他试图执行该代码块的线程将会阻塞等待，直到该代码块被释放。

public class MyRunnable implements Runnable {
    private static int count = 0;

    public synchronized void increase() {
        count++;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            increase();
        }
    }
}

MyRunnable myRunnable = new MyRunnable();
Thread thread1 = new Thread(myRunnable);
Thread thread2 = new Thread(myRunnable);

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

thread1.join();
thread2.join();

System.out.println(MyRunnable.count);

2、Lock接口

Lock接口是Java提供的一种更灵活的线程同步机制，它比synchronized关键字更加强大，支持更多的线程操作。

public class MyRunnable implements Runnable {
    private static int count = 0;
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        lock.lock();
        try {
            for (int i = 0; i < 10000; i++) {
                count++;
            }
        } finally {
            lock.unlock();
        }
    }
}

MyRunnable myRunnable = new MyRunnable();
Thread thread1 = new Thread(myRunnable);
Thread thread2 = new Thread(myRunnable);

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

thread1.join();
thread2.join();

System.out.println(MyRunnable.count);

3、volatile关键字

volatile关键字用于保证线程间变量的可见性，它可以保证一个线程修改共享变量的值后，其他线程可以立即看到修改后的值。

public class MyRunnable implements Runnable {
    private static volatile int count = 0;

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            count++;
        }
    }
}

MyRunnable myRunnable = new MyRunnable();
Thread thread1 = new Thread(myRunnable);
Thread thread2 = new Thread(myRunnable);

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

thread1.join();
thread2.join();

System.out.println(MyRunnable.count);

四、线程通信

线程通信是指多个线程在完成各自任务的基础上，通过合作来完成整个程序的运行。Java中线程通信的实现主要依靠wait()、notify()和notifyAll()方法。

public class Message {
    private String msg;

    public synchronized String getMsg() {
        while (msg == null) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        String ret = msg;
        msg = null;
        notifyAll();
        return ret;
    }

    public synchronized void setMsg(String msg) {
        while (this.msg != null) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.msg = msg;
        notifyAll();
    }
}

Message msg = new Message();

Thread sender = new Thread(() -> {
    for (int i = 0; i < 100; i++) {
        msg.setMsg("Message " + i);
    }
});

Thread receiver = new Thread(() -> {
    for (int i = 0; i < 100; i++) {
        System.out.println(msg.getMsg());
    }
});

sender.start();
receiver.start();

sender.join();
receiver.join();

五、总结

本文介绍了Java多线程编程的基础知识，包括线程的基本概念、创建线程的方法、线程同步、线程通信等内容。Java多线程编程的实现方式非常丰富，程序员需要根据实际业务需求选择适当的线程实现方式。同时，Java多线程编程在提高程序效率的同时，也需要注意线程安全问题，保证程序正确性。