3分钟入门Java多线程

如何在程序中创建出多条线程？

继承Thread类

java">public class MyThread extends Thread {@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println("MyThread运行了" + i);}}
}

实现Runnable接口

java">public class MyRunnable implements Runnable {@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println("MyRunnable运行了" + i);}}
}

利用Callable接口、FutureTask类来实现

java">public class MyCallable implements Callable<String> {@Overridepublic String call() {return "base.MyCallable 运行了";}
}

测试类

java">public class TestThread {public static void main(String[] args) throws Exception {base.MyThread myThread = new base.MyThread();myThread.start();Runnable myRunnable = new base.MyRunnable();new Thread(myRunnable).start();Callable<String> myCallable = new MyCallable();FutureTask<String> futureTask = new FutureTask<>(myCallable);new Thread(futureTask).start();for (int i = 0; i < 10; i++) {System.out.println("main运行了" + i);}// 获取线程执行结果// 如果说程序执行到这，但是myCallable里面的方法还没有执行完，这里会等待，等待方法结束拿到值。String s = futureTask.get();System.out.println(s);}
}

多线程常用方法

线程安全问题

首先，什么是线程安全问题呢？
线程安全问题指的是，多个线程同时操作同一个共享资源的时候，可能会出现业务安全问题。

下面通过一个取钱的案例给同学们演示一下。案例需求如下

场景：小明和小红是一对夫妻，他们有一个共享账户，余额是10万元，小红和小明同时来取钱，并且2人各自都在取钱10万元，可能出现什么问题呢？

如下图所示，小明和小红假设都是一个线程，本类每个线程都应该执行完三步操作，才算是完成的取钱的操作。但是真实执行过程可能是下面这样子的

① 小红线程只执行了判断余额是否足够（条件为true），然后CPU的执行权就被小红线程抢走了。

② 小红线程也执行了判断了余额是否足够（条件也是true）, 然后CPU执行权又被小明线程抢走了。

③ 小明线程由于刚才已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为0。然后CPU执行权又被小红线程抢走。

④ 小红线程由于刚刚也已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为-10万。
在这里插入图片描述

线程安全问题的代码演示

先定义一个共享的账户类

java">public class Account {private String cardId; // 卡号private double money; // 余额。public Account() {}public Account(String cardId, double money) {this.cardId = cardId;this.money = money;}// 小明 小红同时过来的public void drawMoney(double money) {// 先搞清楚是谁来取钱？String name = Thread.currentThread().getName();// 1、判断余额是否足够if(this.money >= money){System.out.println(name + "来取钱" + money + "成功！");this.money -= money;System.out.println(name + "来取钱后，余额剩余：" + this.money);}else {System.out.println(name + "来取钱：余额不足~");}}public String getCardId() {return cardId;}public void setCardId(String cardId) {this.cardId = cardId;}public double getMoney() {return money;}public void setMoney(double money) {this.money = money;}
}

在定义一个是取钱的线程类

java">public class DrawThread extends Thread{private Account acc;public DrawThread(Account acc, String name){super(name);this.acc = acc;}@Overridepublic void run() {// 取钱(小明，小红)acc.drawMoney(100000);}
}

最后，再写一个测试类，在测试类中创建两个线程对象

java">public class ThreadTest {public static void main(String[] args) {// 1、创建一个账户对象，代表两个人的共享账户。Account acc = new Account("ICBC-110", 100000);// 2、创建两个线程，分别代表小明 小红，再去同一个账户对象中取钱10万。new DrawThread(acc, "小明").start(); // 小明new DrawThread(acc, "小红").start(); // 小红}
}

运行程序，执行后。你会发现两个人都取了10万块钱，余额为-10万了。

线程同步方案

为了解决前面的线程安全问题，我们可以使用线程同步思想。同步最常见的方案就是加锁，意思是每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动释放锁，然后其他线程才能再加锁进来。
采用加锁的方案，就可以解决前面两个线程都取10万块钱的问题。怎么加锁呢？Java提供了三种方案

1.同步代码块
2.同步方法
3.Lock锁

同步代码块

什么是同步代码块呢？
被synchorized关键字修饰的代码块被称为同步代码块

java">//锁对象：必须是一个唯一的对象（同一个地址）
synchronized(锁对象){//...访问共享数据的代码...
}

同步代码块有什么作用呢？
它的作用就是把访问共享数据的代码锁起来，以此保证线程安全。
使用同步代码块，来解决前面代码里面的线程安全问题。我们只需要修改DrawThread类中的代码即可。

java">// 小明 小红线程同时过来的
public void drawMoney(double money) {// 先搞清楚是谁来取钱？String name = Thread.currentThread().getName();// 1、判断余额是否足够// this正好代表共享资源！synchronized (this) {if(this.money >= money){System.out.println(name + "来取钱" + money + "成功！");this.money -= money;System.out.println(name + "来取钱后，余额剩余：" + this.money);}else {System.out.println(name + "来取钱：余额不足~");}}
}

最后，再说一下锁对象如何选择的问题

1.建议把共享资源作为锁对象，不要将随便无关的对象当作锁对象
2.对于实例方法，默认使用this作为锁对象
3.对于静态方法，默认使用类的字节码（类名.class）当作锁对象

同步方法

接下来，学习同步方法解决线程安全问题。其实同步方法，就是把整个方法给锁住，一个线程调用这个方法，另一个线程调用的时候就执行不了，只有等上一个线程调用结束，下一个线程调用才能继续执行。

java">// 同步方法
public synchronized void drawMoney(double money) {// 先搞清楚是谁来取钱？String name = Thread.currentThread().getName();// 1、判断余额是否足够if(this.money >= money){System.out.println(name + "来取钱" + money + "成功！");this.money -= money;System.out.println(name + "来取钱后，余额剩余：" + this.money);}else {System.out.println(name + "来取钱：余额不足~");}
}

Lock锁

Lock锁是JDK5版本专门提供的一种锁对象，通过这个锁对象的方法来达到加锁，和释放锁的目的，使用起来更加灵活。格式如下：

java">1.首先在成员变量位子，需要创建一个Lock接口的实现类对象（这个对象就是锁对象）private final Lock lk = new ReentrantLock();
2.在需要上锁的地方加入下面的代码lk.lock(); // 加锁//...中间是被锁住的代码...lk.unlock(); // 解锁

使用Lock锁改写前面DrawThread中取钱的方法，代码如下:

java">// 创建了一个锁对象
private final Lock lk = new ReentrantLock();public void drawMoney(double money) {// 先搞清楚是谁来取钱？String name = Thread.currentThread().getName();try {lk.lock(); // 加锁// 1、判断余额是否足够if(this.money >= money){System.out.println(name + "来取钱" + money + "成功！");this.money -= money;System.out.println(name + "来取钱后，余额剩余：" + this.money);}else {System.out.println(name + "来取钱：余额不足~");}} catch (Exception e) {e.printStackTrace();} finally {lk.unlock(); // 解锁}}
}