Java多线程

Java多线程

一、多线程的实现方式

1、继承Thread类2、实现Rannable接口3、实现Callable接口 二、线程同步

1、同步代码块2、同步方法3、Lock锁 一、多线程的实现方式 1、继承Thread类

优点：编程比较简单，可以直接使用Thread类中的方法
缺点：扩展性较差，不能再继承其他类，不能返回线程执行结果

public class ThreadDemo1 { public static void main(String[] args) { // 3、new一个新线程对象 Thread t = new MyThread(); // 4、调用start方法启动线程（执行的还是run方法） t.start(); for (int i = 0; i < 5; i++) { System.out.println("主线程执行输出：" + i); } }}class MyThread extends Thread{ @Override public void run() { for (int i = 0; i < 5; i++) { System.out.println("子线程执行输出：" + i); } }}

2、实现Rannable接口

优点：扩展性强，实现该接口的同时还可以继承其他类
缺点：编程相对复杂，不能返回线程的执行结果

public class ThreadDemo2 { public static void main(String[] args) { // 3、创建一个任务对象 Runnable target = new MyRunnable(); // 4、把任务对象交给Thread处理 Thread t = new Thread(target); // Thread t = new Thread(target, "1号"); // 5、启动线程 t.start(); for (int i = 0; i < 10; i++) { System.out.println("主线程执行输出：" + i); } }}class MyRunnable implements Runnable { @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println("子线程执行输出：" + i); } }}

3、实现Callable接口

优点：扩展性强，实现该接口的同时还可以继承其他类，可以得到线程执行返回的结果
缺点：编程相对复杂

import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;public class ThreadDemo3 { public static void main(String[] args) { // 3、创建Callable任务对象 Callable call = new MyCallable(100); // 4、把Callable任务对象 交给 FutureTask 对象 // FutureTask对象的作用1： 是Runnable的对象（实现了Runnable接口），可以交给Thread了 // FutureTask对象的作用2： 可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果 FutureTask f1 = new FutureTask<>(call); // 5、交给线程处理 Thread t1 = new Thread(f1); // 6、启动线程 t1.start(); Callable call2 = new MyCallable(200); FutureTask f2 = new FutureTask<>(call2); Thread t2 = new Thread(f2); t2.start(); try { // 如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果。 String rs1 = f1.get(); System.out.println("第一个结果：" + rs1); } catch (Exception e) { e.printStackTrace(); } try { // 如果f2任务没有执行完毕，这里的代码会等待，直到线程2跑完才提取结果。 String rs2 = f2.get(); System.out.println("第二个结果：" + rs2); } catch (Exception e) { e.printStackTrace(); } }}class MyCallable implements Callable{ private int n; public MyCallable(int n) { this.n = n; } @Override public String call() throws Exception { int sum = 0; for (int i = 1; i <= n ; i++) { sum += i; } return "子线程执行的结果是：" + sum; }}

二、线程同步 1、同步代码块

synchronized(同步锁对象){操作共享资源的代码(核心代码)}//小红小明有一个共享账户，内有10w，二人现在都需要取10w public void drawMoney(double money) { // 1、拿到是谁来取钱 String name = Thread.currentThread().getName(); // 同步代码块 // 小明 小红 // this == acc 共享账户 synchronized (this) { // 2、判断余额是否足够 if(this.money >= money){ // 钱够了 System.out.println(name+"来取钱，吐出：" + money); // 更新余额 this.money -= money; System.out.println(name+"取钱后，余额剩余：" + this.money); }else{ // 3、余额不足 System.out.println(name+"来取钱，余额不足！"); } } }

锁对象要求：对当前同时执行的线程来说是唯一对象即可
但使用任意唯一对象可能会影响其他无关线程，于是有：

锁对象规范要求：
建议使用共享资源作为锁对象
对于实例方法建议使用this作为锁对象
对于静态方法建议使用字节码(类名.class)作为锁对象

2、同步方法

修饰符 synchronized 返回值类型 方法名称(形参列表){操作共享资源代码} public synchronized void drawMoney(double money) { // 1、拿到是谁来取钱 String name = Thread.currentThread().getName(); // 2、判断余额是否足够 // 小明 小红 if(this.money >= money){ // 钱够了 System.out.println(name+"来取钱，吐出：" + money); // 更新余额 this.money -= money; System.out.println(name+"取钱后，余额剩余：" + this.money); }else{ // 3、余额不足 System.out.println(name+"来取钱，余额不足！"); } }

同步方法底层原理
同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
如果方法是实例方法:同步方法默认用this作为的锁对象。但是代码要高度面向对象!
如果方法是静态方法:同步方法默认用类名.class作为的锁对象。

3、Lock锁

public void drawMoney(double money) { // 1、拿到是谁来取钱 String name = Thread.currentThread().getName(); // 2、判断余额是否足够 // 小明 小红 lock.lock(); // 上锁 try { if(this.money >= money){ // 钱够了 System.out.println(name+"来取钱，吐出：" + money); // 更新余额 this.money -= money; System.out.println(name+"取钱后，余额剩余：" + this.money); }else{ // 3、余额不足 System.out.println(name+"来取钱，余额不足！"); } } finally { lock.unlock(); // 解锁 } }