java入门API

入门API"/>

java入门API

线程同步-并发—B站秦疆老师
同一个对象被多个线程同时操作-----并发优先使用LOCK锁—去看lock
处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时，我们据需要线程同步！
线程同步------> 其实 就是一种等待机制-----》多个需要同时访问此对象的线程进入“这个对象的等待池”形成队列，
等待前面的线程使用完毕，下一个线程才使用，，
线程同步形成的安全性条件：
队列和锁：在线程中，要保证安全就需要 队列 和锁，比如上厕所 ，有队列，排队上厕所，由门锁关门；
syn char nized --排它锁，独占资源，其他线程必须等待，使用后释放锁即可
存在问题：1、一个线程持有排它锁时，会使其他需要此锁的线程挂起；
2、在多线程竞争下，加锁释放锁会导致上下文 切换 和 调度延时，引起性能问题
3、若优先级高的A挂起等优先级低的B释放锁，会导致优先级倒置（低变高，高变低）引起性能问题

syn char nized的使用：
第一、修饰方法–控制 对 “对象”的访问，，方法执行，必须等方法全走完才能释放锁
缺点：若将大的方法加锁，会影响效率；
方法里边需要修改的内容才加锁，，锁的太多，浪费资源；
public synchronized void buy(){
//要加锁的内容
}
第二、代码块synchronized (obj) ===>obj也叫同步监视器
synchronized (this){//—（obj）this–锁的对象----推荐使用 共享资源作为同步监视器
要加锁的内容；
}
同步监视器的执行过程
1、第一个线程访问，锁定同步监视器，执行其代码
2、第二个线程访问，发现同步监视器被锁定，无法访问
3、第一个线程访问完毕，释放同步监视器；
4、第二个线程访问，发现同步监视器没锁，然后锁定访问；后续重复

线程通信—线程协作
这是个线程同步问题，生产者和消费者共享同一个资源，并且消费者和生产者之间相互依赖，互为条件（可判定条件）
生产者 消费者：
线程-》生产者-生产：没有生产产品之前，要通知消费者TT等待，而生产了产品（此时TT有产品）后，又需要马上通知消费者消费
中间缓冲区——》取餐台：TT— 数据缓冲区；
线程-》消费者-消费：在消费之后，要通知消费者，已经消费了（此时TT无产品），需要生产新的产品以共消费
在生产者消费者之间问题，仅有syncharnized是不够的：
syncharnized可以阻止并发更新同一个资源，实现同步
syncharnized不能用来实现不同线程之间的信息传递（通信）
java提供了几个方法解决线程之间的通信问题，，，—是OBJect类的方法—一下方法 只能在同步方法或同步代码块中使用

wait();/表示线程等待，知道其他线程通知， 与sleep不同，它会释放锁
wait(long timeout);//指定等待的毫秒数
notify();//唤醒一个处于等待状态的线程
notifyAll();//唤醒同一个对象上所有调用wait（）方法的线程，优先级别高的线程优先调用；

解决方法：一、并发协作模型— 生产者消费者=====》管程法
生产者：负责生产数据的模块（可能是方法，对象，线程，进程）
消费者：负责处理数据的模块（可能是方法，对象，线程，进程）
缓冲区：消费者不能直接使用生产者生产的数据，他们之间有个缓冲区
生产者将生产好的数据 放入缓冲区，消费者重缓冲区拿数据

//生产者，消费者，产品，缓冲区
public class TestPc {public static void main(String[] args) {SynContainer synContainer = new SynContainer();new Productor(synContainer).start();new Consumer(synContainer).start();}
}
//生产者
class Productor extends Thread{SynContainer synContainer;public Productor(SynContainer synContainer) {this.synContainer = synContainer;}@Overridepublic void run() {for (int i = 1; i < 100; i++) {synContainer.pash(new Chicken(i));System.out.println("生产了"+i+"只鸡");}}
}
//消费者
class Consumer extends Thread{SynContainer synContainer;public Consumer(SynContainer synContainer) {this.synContainer = synContainer;}@Overridepublic void run() {for (int i = 1; i < 100; i++) {System.out.println("消费了第"+synContainer.pop().id+"只鸡");}}
}
//产品
class Chicken{int id;public Chicken(int id) {this.id = id;}
}
//缓冲区
class SynContainer {//需要个容器大小Chicken[] c=new Chicken[100];//需要一个 计算器，，做条件int count=0;//生产者放入产品public synchronized  void  pash(Chicken chicken){//如果容器满了，就需要通知消费者消费if (count==c.length){//通知消费者，消费，生产者等待try {this.wait();//------------------------------------等待} catch (InterruptedException e) {e.printStackTrace();}}//生产者放入产品c[count]=chicken;count++;//可以通知消费者消费了this.notifyAll();//通知消费者 消费---------------------唤醒同一个对象上所有调用wait（）方法的线程，优先级别高的线程优先调用；}//消费者消费public  synchronized  Chicken  pop(){//判断能否消费if (count==0){//等待生产者生产，消费者等待try {this.wait();//------------------------------------等待} catch (InterruptedException e) {e.printStackTrace();}}//可以消费count--;Chicken chicken = c[count];//通知生产者生产this.notifyAll();//通知生产线程 生产  ---------------------唤醒同一个对象上所有调用wait（）方法的线程，优先级别高的线程优先调用；return chicken;}
}

二、并发协作模型— 生产者消费者=====》信号灯法-----标志位
使用一个标志位flag,如果为true ,就让它等待，如果不为就让它通知另外一个人；

package ks.Lambda;
//
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;}@Overridepublic void run() {for (int i = 0; i < 20; i++) {if (1/2==0){this.tv.play("春光灿烂猪八戒");}else {this.tv.play("抖音：记录美好生活");}}}
}
//消费者--观众--只管看
class Watcher extends Thread{Tv tv;public Watcher(Tv tv) {this.tv = tv;}@Overridepublic void run() {for (int i = 0; i < 20; i++) {this.tv.wach();}}
}
//产品--节目
class Tv{//逻辑：演员表演，观众等待 T//观众观看，演员等待  FString 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 wach(){if (flag){try {this.wait();//---------------------------------------------等待} catch (InterruptedException e) {e.printStackTrace();}}else {System.out.println("正在观看。。看完了");//通知演员表演this.notifyAll();//---------------------------------------------通知运行this.flag=!this.flag;}}
}

线程池 —jdk5提供了2个api
背景：经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大；
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中；
可以避免频繁创建和销毁，实现重复利用；

核心好处：
1、提高响应速度（减少了创建新线程的时间）
2、降低资源消耗（重复使用线程池中的线程，不需要每次都创建）
3、便于线程管理
1-corePoolSize:核心池的大小
2-maximumPoolSize:最大线程数
3-KeepAliveTime:线程没有任务时最多保存多长时间后会终止
ExecutorService：-----真正的线程池接口（是接口故不能new，只能子类实现）
====》常见子类实现类–ThreadPool Executor
方法：void execute(Runnable command):执行任务/命令，无返回值，一般用来执行Runnable
Futuresubmit(Callabletask):执行任务，有返回值，一般执行callable
上边ExecutorService的实现类–》Executors: 工具类、线程池的工厂类，用于创建并返回不同类型的线程池
ExecutorService （接口） service= （实现类）Executors.newFixedThreadPool(10);

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;//线程池
public class TestPool {public static void main(String[] args) {//创建服务，创建线程池//newFixedThreadPool线程池大小ExecutorService service=Executors.newFixedThreadPool(10);//执行service.execute(new myThread());service.execute(new myThread());service.execute(new myThread());service.execute(new myThread());service.shutdownNow();}}class myThread implements Runnable{@Overridepublic void run() {System.out.println(Thread.currentThread().getName());}
}