Java基础（四）

前言：本博客主要涉及java编程中的线程、多线程、生成者消费者模型、死锁。

线程多线程

线程同步

synchronized

Lock锁

线程通信

生产者消费者模型

线程池

使用线程池处理Runnable任务

使用线程池处理Callable任务

Excutors

悲观锁

乐观锁

并发VS并行

线程的生命周期

线程多线程

创建一个简单的线程

获取执行当前代码的线程名：Thread.currentThread().getName()

开启线程：对象名.start()

守护线程优先级

//1.创建一个继承于Thread类的子类
class MyThread extends Thread {//2.重写Thread类的run()@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println(Thread.currentThread().getName() + ":" + i);}}
}public class ThreadTest {public static void main(String[] args) {MyThread t1 = new MyThread();t1.start();}
}

package learn12;class MyRunnable implements Runnable {@Overridepublic void run() {for (int i = 1; i <= 5; i++) {System.out.println("子线程输出：" + i);}}
}public class MyThreadTest2 {public static void main(String[] args) {Runnable target = new MyRunnable();new Thread(target).start();for (int i = 1; i <= 5; i++) {System.out.println("主线程main输出：" + i);}}}

线程安全

例子：多个人同时去一个账户里取钱，被取出后，不能再取出钱。但多个线程执行时，在访问时，账户里有钱的，但实际上已经被其他用户取走，此时再取钱就会引发数据不安全的问题。

使用多线程时，每个线程都对数据进行修改，如何来保证数据的安全性？

package learn12;public class Account {private String cardId;private double money;public Account() {}public Account(String cardId, double money) {this.cardId = cardId;this.money = money;}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;}public void drawMoney(double money) {String name = Thread.currentThread().getName();if (this.money >= money) {System.out.println(name + "来取钱" + money + "成功！");this.money -= money;System.out.println(name + "来取钱，此时剩余：" + this.money);} else {System.out.println(name + "来取钱，但余额不足");}}
}

package learn12;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);}
}

package learn12;public class ThreadTest {public static void main(String[] args) {Account acc = new Account("ICBC-100", 100000);new DrawThread(acc, "小明").start();new DrawThread(acc, "小红").start();new DrawThread(acc, "小李").start();}
}

线程同步

使用了加锁的机制

synchronized

用到了同步控制关键字synchronized

用其修饰成员方法，被修饰的方法，在同一时间，只能被一个线程执行

//同步方法
public synchronized void drawMoney(double money) {String name = Thread.currentThread().getName();
//同步代码块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 + "来取钱，但余额不足");}}}

Lock锁

注意：解锁要放在finally里，以便程序出错时，可以解锁。

package learn12;import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class Account {private String cardId;private double money;//创建Lock锁对象private final Lock lk = new ReentrantLock();public Account() {}public Account(String cardId, double money) {this.cardId = cardId;this.money = money;}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;}public void drawMoney(double money) {String name = Thread.currentThread().getName();//加锁lk.lock();try {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();}}
}

线程通信

生产者线程负责生产数据

消费者线程负责消费生产者产生的数据

生产者消费者模型

package learn12;import java.util.ArrayList;
import java.util.List;public class Desk {private List<String> list = new ArrayList<>();public synchronized void put() {try {String name = Thread.currentThread().getName();if (list.size() == 0) {list.add(name + "做的肉包子");System.out.println(name + "做了一个肉包子");Thread.sleep(2000);//唤醒别人 等待自己this.notifyAll();this.wait();} else {//唤醒别人 等待自己this.notifyAll();this.wait();}} catch (InterruptedException e) {e.printStackTrace();}}public synchronized void get() {try {String name = Thread.currentThread().getName();if (list.size() == 1) {System.out.println(name + "吃了：" + list.get(0));list.clear();Thread.sleep(1000);//唤醒别人 等待自己this.notifyAll();this.wait();} else {//唤醒别人 等待自己this.notifyAll();this.wait();}} catch (InterruptedException e) {e.printStackTrace();}}
}

package learn12;public class ThreadTest4 {public static void main(String[] args) {Desk desk = new Desk();//生产者线程new Thread(() -> {while (true) {desk.put();}}, "厨师1").start();new Thread(() -> {while (true) {desk.put();}}, "厨师2").start();new Thread(() -> {while (true) {desk.put();}}, "厨师3").start();//消费者线程new Thread(() -> {while (true) {desk.get();}}, "吃货1").start();new Thread(() -> {while (true) {desk.get();}}, "吃货2").start();}
}

线程池

线程池就是一个可以复用线程的技术。

使用线程池的必要性：

用户发起一个请求，后台就需要创建一个新线程。不使用线程池，会产生大量的线程，会损害系统的性能。

线程池可以固定线程和执行任务的数量，可以避免系统瘫痪和线程耗尽的风险。

创建线程池

临时线程什么时候创建？

新任务提交时，发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时会创建临时线程。

什么时候可以拒绝新任务？

核心线程和临时线程都在忙，任务队列都满了，新的任务过来时才会开始拒绝任务。

使用线程池处理Runnable任务

package learn12;public class MyRunnableLearn implements Runnable {@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + "==>输出666");try {Thread.sleep(Integer.MAX_VALUE);} catch (InterruptedException e) {e.printStackTrace();}}
}

package learn12;import java.util.concurrent.*;public class ThreadPoolTest {public static void main(String[] args) {//创建线程池对象
//        new ThreadPoolExecutor(
//                                int corePoolSize,
//                                int maximumPoolSize,
//                                long keepAliveTime,
//                                TimeUnit unit,
//                                BlockingQueue<Runnable> workQueue,
//                                ThreadFactory threadFactory,
//                                RejectedExecutionHandler handler
//        )ExecutorService pool = new ThreadPoolExecutor(3, 5, 8,TimeUnit.SECONDS, new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());Runnable target = new MyRunnableLearn();pool.execute(target);pool.execute(target);pool.execute(target);pool.execute(target);pool.execute(target);pool.execute(target);pool.execute(target);pool.execute(target);pool.execute(target);//都满了 拒绝新任务pool.execute(target);
//        pool.shutdownNow();//pool.shutdown();}
}

使用线程池处理Callable任务

package learn12;import java.util.concurrent.Callable;public class MyCallable implements Callable<String> {private int n;public MyCallable(int n) {this.n = n;}@Overridepublic String call() throws Exception {int sum = 0;for (int i = 1; i <= n; i++) {sum += i;}return Thread.currentThread().getName() + "求出了1-" + n + "的和是：" + sum;}
}

package learn12;import java.util.concurrent.*;public class ThreadPoolTest2 {public static void main(String[] args) throws Exception {ExecutorService pool = new ThreadPoolExecutor(3, 5, 8,TimeUnit.SECONDS, new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),new ThreadPoolExecutor.CallerRunsPolicy());//使用线程池处理Callbable任务Future<String> f1 = pool.submit(new MyCallable(100));Future<String> f2 = pool.submit(new MyCallable(200));Future<String> f3 = pool.submit(new MyCallable(300));//复用前面的线程Future<String> f4 = pool.submit(new MyCallable(400));System.out.println(f1.get());System.out.println(f2.get());System.out.println(f3.get());System.out.println(f4.get());}
}

Excutors

大型并发系统环境中使用Excutors如果不注意可能会出现系统风险。

核心线程数

计算密集型任务：核心线程数量 = CPU核数+1

IO密集型任务：核心线程数量 = CPU核数*2

package learn12;import java.util.concurrent.*;public class ThreadPoolTest2 {public static void main(String[] args) throws Exception {//通过Executors创建一个线程池对象ExecutorService pool = Executors.newFixedThreadPool(3);Executors.newSingleThreadExecutor();//使用线程池处理Callbable任务Future<String> f1 = pool.submit(new MyCallable(100));Future<String> f2 = pool.submit(new MyCallable(200));Future<String> f3 = pool.submit(new MyCallable(300));//复用前面的线程Future<String> f4 = pool.submit(new MyCallable(400));System.out.println(f1.get());System.out.println(f2.get());System.out.println(f3.get());System.out.println(f4.get());}
}

悲观锁

一开始就加锁，每次只能一个线程进入访问完毕后，再解锁，线程安全，性能较差。

package learn12;public class MyRunnable implements Runnable {public int count;@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println(this);synchronized (this) {System.out.println("count ===>" + (++count));}}}
}

package learn12;public class Test {public static void main(String[] args) {Runnable target = new MyRunnable();for (int i = 1; i <= 100; i++) {new Thread(target).start();}}
}

乐观锁

一开始不上锁，等要出现线程安全问题时，等要出现线程安全问题时，线程安全，性能较好。

如何实现乐观锁

private AtomicInteger count = new AtomicInteger();

package learn12;import java.util.concurrent.atomic.AtomicInteger;public class MyRunnable implements Runnable {private AtomicInteger count = new AtomicInteger();@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println(this);synchronized (this) {System.out.println("count ===>" + count.incrementAndGet());}}}
}