前言:本博客主要涉及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());}}}
}
并发VS并行
python进阶学习也涉及到这里的知识点。
Python进阶(二)-CSDN博客
进程:正在运行的程序
线程:一个进程中可以运行多个线程
并发:线程是由CPU调度执行的,但CPU能同时处理的线程数量有限,为了保证全部线程都能执行,CPU会轮询为系统的每个线程服务,由于CPU切换的速度很快,好像是线程在同时执行,这就是并发。
并行:同一时间点,任务同时地运行,比如一台电脑,有8个CPU,每个CPU的每个核心都可以独立地执行一个任务,在同一时间点,可同时执行8个任务,这时任务是同时执行,并行地运行任务。
线程的生命周期
New:新建
Runnable:可运行
Timinated:被终止
Timed Waiting:计时等待
Waiting:无线等待
Blocked:阻塞