线程学习2022/3/4后半段
线程同步
线程同步就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程在使用
多个对象操作同一个资源，并发
队列+锁
synchronized，当一个线程获得对象的排他锁，独占资源，其他线程必须等待他使用后释放锁才能继续使用。存在问题
一个线程持有锁会导致其他需要此锁的线程挂起
在多线程竞争下，加锁，释放锁会导致比较多的上下文切换 和调度延时，引起性能问题
如果一个优先度高的线程等待一个优先度第的线程释放锁，会导致优先级倒置，引起性能问题
Synchronized 关键字包含2种用法
synchronized 方法和 synchronized 块
同步方法 public synchronized void method（int）{ }
synchronized 方法控制对象的访问，每一个对象对应一把锁，每个synchronized 方法都必须获得调用该方法的对象的锁才能执行，否则会阻塞线程，
方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
缺陷，如果将一个大的方法申请为Synchronized 将会影响效率。
同步块 synchronized（Cbj）{ }
Obj称为同步监视器
Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class（反射中讲解）
同步监视器的执行过程
第一，线程访问，锁定同步监视器，执行其中的代码
第二，线程访问，发现同步监视器被锁定，无法访问
第一个线程访问完毕，解锁同步监视器
第二个线程访问，发现同步监视器没有锁，然后锁定并且访问
同步方法 同步代码块 第一个线程进来拿到锁，后面的人排队，直到释放，后面的才能进去
死锁，互斥，请求与保持，不剥夺条件，循环等待
死锁
多个线程各自占有一些共享资源，并且需要相互等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情况，
某一个同步代码块同时拥有 两个以上的对象锁 时，就可能会发生死锁问题
死锁的四个必要条件
-
互斥条件；一个资源每次只能被一个进程使用
-
请求与保持条件；一个进程因请求资源而被阻塞时，对已经获得的资源保持不放
-
不剥夺条件；进程已经获得的资源，在未使用完之前，不能被强行剥夺
-
循环等待条件；若干进程之间形成一种头尾相接的循环等待资源关系
lock juc
从jdk5开始，java提供了更强大的线程同步机制-----通过显示定义同步锁对象来实现同步，同步锁使用Lock对象充当。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。
锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
ReentrantLock 类实现了Lock，它拥有与synchronized 相同的并发性和内存语义，在实现线程安全的控制中，
比较常用的是ReentrantLock ，可以显示加锁. 释放锁
class A{
private final ReentrantLock lock =new ReentrantLock();
public void m(){
lock.lock();
try{
//保证线程安全的代码
}
finally{
lock.unlock();
//如果同步代码有异常，要将unlock()写入finally语句块
}
}
}lock（优先级高）.
lock是显示锁，（手动开启和关闭锁，别忘啦关闭锁）synchronized是隐式锁，出来作用域自动释放
lock只有代码块锁，synchronized有代码块锁和方法锁
使用lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性
优先级顺序
Lock>同步代码块>同步方法
trylock
unlock
线程通信 缓冲区，消息队列 标志位 红绿灯 wait notifyAll
//测试；生产者消费者模型，---》利用缓冲区
//生产者，消费者，产品，缓冲区
public class TestPC {
public static void main(String[] args) {
SynContainer container=new SynContainer();
new Productor(container).start();
new Consumer(container).start();
}
}
//生产者
class Productor extends Thread{
SynContainer container;
public Productor(SynContainer container){
this.container =container;
}
//生产
@Override
public void run() {
for (int i = 0; i < 100; i++) {
container.push(new Chicken(i));
System.out.println("生产了"+i+"只鸡");
}
}
}
//消费者
class Consumer extends Thread{
SynContainer container;
public Consumer(SynContainer container){
this.container =container;
}
//消费
@Override
public void run() {
for (int i = 0; i <100 ; i++) {
System.out.println("消费了"+container.pop().id+"只鸡");
}
}
}
//产品
class Chicken{
int id;//产品编号
public Chicken(int id) {
this.id = id;
}
}
//缓冲区
class SynContainer{
//需要一个容器大小
Chicken[] chickens = new Chicken[10];
//容器计数器
int count=0;
//生产者放入产品
public synchronized Chicken push(Chicken chicken){
//如果容器满了，就需要等待消费者，如果没有满就需要丢人产品
while (count==chickens.length){
try {
this.wait();
}catch (InterruptedException e){
e.printStackTrace();
}
}
//如果没有满，我们就需要丢人产品
chickens[count] =chicken;
count++;
//可以通知消费者消费
this.notifyAll();
return chicken;
}
//消费者消费产品
public synchronized Chicken pop(){
//判断能否消费
while (count==0){
try {
this.wait();
}catch (InterruptedException e){
e.printStackTrace();
}
}
//如果可以消费
count--;
Chicken chicken=chickens[count];
//吃完通知生产这，生产
this.notifyAll();
return chicken;
}
} //测试生产者消费者问题2；信号灯法，标志位
public class TestPc2 {
public static void main(String[] args) {
TV tv =new TV();
new Player(tv).start();
new Watcher(tv).start();
}
}
//生产者--》演员
class Player extends Thread{
TV tv;
public Player(TV tv){
this.tv =tv;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
if (i%2==0){
this.tv.play("表演小品中");
}else {
this.tv.play("刷视频");
}
}
}
}
//消费者--》观众
class Watcher extends Thread{
TV tv;
public Watcher(TV tv){
this.tv =tv;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
tv.watch();
}
}
}
//产品---》节目
class TV{
//演员表演，观众等待
//观众观看，演员等待
String voice;//表演的节目
boolean flag =true;
//表演
public synchronized void play(String voice){
if (!flag)
try {
this.wait();
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("演员表演了"+voice);
//通知观众观看
this.notifyAll();
this.voice =voice;
this.flag =!this.flag;
}
//观看
public synchronized void watch(){
if (flag)
try {
this.wait();
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("观看了"+voice);
//通知演员表演
this.notifyAll();
this.flag =!this.flag;
}
}线程池pool 池化技术，池的大小，最大连接，保持时间
经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能的影响很大
思路，提前创建好多个线程，放入线程池中，使用的时候直接获取，使用完放回池中
可以避免频繁创建和销毁，实现重复利用。
好处，
提高响应速度（减少创建新线程的时间）
降低资源消耗（重复利用线程池中的线程，不需要每次都创建线程）
便于管理线程
corePoolSize 核心池的大小
maxmunPoolSize 最大线程数
keepAlivetime 线程没有任务时最多保存多长时间后会终止
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestPool {
public static void main(String[] args) {
//创建线程池
//线程池大小10
ExecutorService service = Executors.newFixedThreadPool(10);
//执行
service.execute(new MyThead());
service.execute(new MyThead());
service.execute(new MyThead());
service.execute(new MyThead());
//关闭连接
service.shutdown();
}
}
class MyThead implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
