Java并发编程示例(一)：线程的创建和执行

Java并发编程示例(一)：线程的创建和执行

前言

Java是一门支持多线程编程的语言，多线程编程可以有效地提高程序的执行效率，特别是在涉及到网络编程、I/O操作以及复杂的计算任务时。本篇文章将会介绍Java中如何创建线程以及如何执行线程。

Java中的线程

Java中的线程是通过Thread类来实现的。在Java中创建线程有两种方式：继承Thread类和实现Runnable接口。前者需要重写Thread类中的run()方法，后者需要实现Runnable接口中的run()方法。

//继承Thread类创建线程
public class MyThread extends Thread {
    public void run() {
        System.out.println("This is a thread created by extending Thread class.");
    }
}

//实现Runnable接口创建线程
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("This is a thread created by implementing Runnable interface.");
    }
}

创建线程并启动线程

在创建了线程对象之后，需要使用start()方法来启动线程。调用start()方法后，线程进入就绪状态，等待CPU调度执行。

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

        MyRunnable r1 = new MyRunnable();
        Thread t2 = new Thread(r1);
        t2.start();
    }
}

这样就可以成功地创建并启动两个线程。

示例一：多线程排序

下面我们通过一个简单的排序示例来说明多线程的作用。在这个示例中，我们将会创建两个线程，一个线程用来对数组进行从大到小排序，另一个线程用来对数组进行从小到大排序。在某些情况下，我们需要同时对数组进行不同顺序的排序，这就需要使用多线程。

public class Sort {

    public static void main(String[] args) {
        int[] arr = {4, 5, 8, 9, 1, 3, 6, 2, 7, 0};

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                Arrays.sort(arr);
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                Arrays.sort(arr);
                for (int i = 0; i < arr.length / 2; i++) {
                    int temp = arr[i];
                    arr[i] = arr[arr.length - 1 - i];
                    arr[arr.length - 1 - i] = temp;
                }
            }
        });

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

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

        System.out.println(Arrays.toString(arr));
    }
}

在上面的代码中，我们首先定义了一个长度为10的整型数组，然后创建了两个线程t1和t2，t1用来对数组进行从小到大排序，t2用来对数组进行从大到小排序。最后，我们使用了t1.join()和t2.join()方法保证了t1和t2线程执行完毕后再获取数组的值并输出到控制台。

示例二：多线程模拟银行取款

下面我们来看一个另一个示例：多线程模拟银行取款。在这个示例中，假设有一对夫妻在一家银行开了一个共同账户，他们一起来到银行取款，现在需要模拟这个过程。

public class BankAccount {

    private int balance = 10000;

    public synchronized void withdraw(int amount) {
        if (balance >= amount) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            balance -= amount;
            System.out.println(Thread.currentThread().getName() + " withdrew " + amount + ", balance is " + balance);
        } else {
            System.out.println(Thread.currentThread().getName() + " tried to withdraw " + amount + ", balance is not enough.");
        }
    }
}

public class WithdrawThread implements Runnable {

    private BankAccount bankAccount;
    private int withdrawAmount;

    public WithdrawThread(BankAccount bankAccount, int withdrawAmount) {
        this.bankAccount = bankAccount;
        this.withdrawAmount = withdrawAmount;
    }

    @Override
    public void run() {
        bankAccount.withdraw(withdrawAmount);
    }
}

public class Main {

    public static void main(String[] args) {
        BankAccount bankAccount = new BankAccount();
        Thread t1 = new Thread(new WithdrawThread(bankAccount, 5000), "Jack");
        Thread t2 = new Thread(new WithdrawThread(bankAccount, 4000), "Jane");
        Thread t3 = new Thread(new WithdrawThread(bankAccount, 3000), "Jeff");

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

在上面的示例中，我们首先定义了一个名为BankAccount的类，用来表示夫妻共同的账户。BankAccount类中只有一个withdraw方法，方法中首先做的是判断余额是否足够，如果足够，则让线程休眠一会儿（模拟网络延迟等情况），然后进行相应的取款操作；如果余额不足，则直接输出提示信息。

接下来我们定义了一个WithdrawThread类，该类用来表示取款线程。在构造方法中我们传入了一个BankAccount实例和一个取款金额，然后在run()方法中调用bankAccount的withdraw方法。

最后，在Main类中，我们创建了三个取款线程t1、t2和t3，每个线程分别要取5000、4000和3000元。运行程序后输出的结果如下：

Jack withdrew 5000, balance is 5000
Jane withdrew 4000, balance is 1000
Jeff tried to withdraw 3000, balance is not enough.

从上面的输出结果可以看出，三个线程都访问了同一个BankAccount实例，但是由于使用了同步锁，线程是依次进行的，比如当Jack线程在进行withdraw方法时，其他线程都要等待Jack线程结束后才开始执行。