Java多线程技术详解

Java 多线程技术详解

引言

多线程是Java并发编程中的核心概念，它允许程序同时执行多个任务。通过合理利用多线程，可以显著提高程序的运行效率和响应速度。本文将详细介绍Java中的多线程技术，包括线程的基本概念、创建线程的方式、线程同步与线程安全等。

创建线程

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

继承Thread类

通过继承Thread类，并重写其run方法，可以创建一个新的线程。


class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread is running");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start(); // 启动线程
    }
}

实现Runnable接口

实现Runnable接口是创建线程的另一种方式，这种方式更加灵活，因为它允许一个类继承其他类，同时实现Runnable接口。


class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("MyRunnable is running");
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start(); // 启动线程
    }
}

线程同步

多线程编程中，线程同步是一个非常重要的问题。如果多个线程同时访问共享资源，可能会导致数据不一致的问题。Java提供了多种机制来实现线程同步，包括synchronized关键字、Lock接口等。

synchronized关键字

synchronized关键字可以用来修饰方法或代码块，以实现线程同步。


class Counter {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i  {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + counter.getCount()); // 输出结果应为2000
    }
}

案例讲解

下面是一个简单的银行转账案例，展示了如何使用synchronized关键字实现线程同步。


class Account {
    private double balance;

    public Account(double balance) {
        this.balance = balance;
    }

    public synchronized void deposit(double amount) {
        balance += amount;
        System.out.println(Thread.currentThread().getName() + " deposited: " + amount);
    }

    public synchronized void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
            System.out.println(Thread.currentThread().getName() + " withdrew: " + amount);
        } else {
            System.out.println("Insufficient balance");
        }
    }

    public double getBalance() {
        return balance;
    }
}

public class BankTransfer {
    public static void main(String[] args) {
        Account account1 = new Account(1000);
        Account account2 = new Account(1500);

        Thread t1 = new Thread(() -> {
            account1.withdraw(500);
            account2.deposit(500);
        }, "Customer1");

        Thread t2 = new Thread(() -> {
            account2.withdraw(300);
            account1.deposit(300);
        }, "Customer2");

        t1.start();
        t2.start();
    }
}