Java中线程Thread的特点及使用

线程Thread的特点

Java的线程基于操作系统的线程实现，具有如下几个特点：

1. 轻量级：线程的实现机制使得线程拥有更小的内存开销，能够更高效地创建和销毁线程。

2. 独立性：每个线程具有独立的运行空间和状态，互不干扰。

3. 并发性：多个线程可以并发执行，提高程序的运行效率。

4. 共享性：多个线程可以共享同一个进程中的资源，如内存等，提高资源利用率。

线程Thread的使用

Java中的线程是通过Thread类实现的。线程的创建可以通过以下两种方式实现：

继承Thread类

class MyThread extends Thread {
    public void run() {
        //线程具体执行任务的代码
    }
}

//启动线程
MyThread t = new MyThread();
t.start();

实现Runnable接口

class MyRunnable implements Runnable{
    public void run() {
        //线程具体执行任务的代码
    }
}

//启动线程
Thread t = new Thread(new MyRunnable());
t.start();

通常情况下，推荐使用第二种方式实现线程的创建，因为Java不支持多重继承，如果已经继承了Thread类，就无法再继承其他类来实现其他功能。

在多线程程序中，我们可以使用synchronized关键字、ReentrantLock类等来保证线程安全，防止出现竞争条件导致的数据错误问题。

示例一：创建两个线程，一个输出奇数，一个输出偶数

public class ThreadDemo {
    public static void main(String[] args) {
        Thread odd = new Thread(new PrintOdd());
        Thread even = new Thread(new PrintEven());
        odd.start();
        even.start();
    }
}

class PrintOdd implements Runnable {
    public void run() {
        for (int i = 1; i <= 100; i += 2) {
            System.out.print(i + " ");
        }
    }
}

class PrintEven implements Runnable {
    public void run() {
        for (int i = 2; i <= 100; i += 2) {
            System.out.print(i + " ");
        }
    }
}

示例二：模拟银行存取款操作

public class ThreadDemo2 {
    public static void main(String[] args) {
        Account account = new Account();
        new Thread(new Deposit(account)).start();
        new Thread(new Withdraw(account)).start();
    }
}

class Account {
    private double balance = 1000;

    public synchronized void deposit(double amount) {
        balance += amount;
        System.out.println("存款 " + amount + " 后，余额为：" + balance);
    }

    public synchronized void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
            System.out.println("取款 " + amount + " 后，余额为：" + balance);
        } else {
            System.out.println("余额不足！");
        }
    }
}

class Deposit implements Runnable {
    private final Account account;

    public Deposit(Account account) {
        this.account = account;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            account.deposit(100);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Withdraw implements Runnable {
    private final Account account;

    public Withdraw(Account account) {
        this.account = account;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            account.withdraw(200);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

以上是关于Java中线程Thread的特点及使用的完整攻略。本文讲述了线程的特点及创建方法，同时展示了两个示例以帮助读者更好地理解和应用。