Project Modules JDK1.8
java Compiler --> Module typecodeversion 8
线程基础 线程核心概念程序：QQ.exe（硬盘上）
进程：运行程序，放入内存（资源分配的基本单位）
线程：程序执行的基本单元
package org.example;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
//练习Thread,实现多线程同步下载网络图片
public class ThreadPractice extends Thread{
private String url;//网络图片地址
private String name;//保存的文件名
public ThreadPractice(String url,String name){
this.name = name;
this.url = url;
}
//下载图片线程的执行体
public void run() {
WebDownloader webDownloader = new WebDownloader();
webDownloader.downloader(url,name);
System.out.println("下载了文件名为："+name);
}
public static void main(String[] args) {
ThreadPractice t1 = new ThreadPractice("https://tse2-mm.cn.bing.net/th/id/OIP-C.xsA-3qUw6cqmd8nRfxk6TQHaEK?w=298&h=180&c=7&r=0&o=5&dpr=1.25&pid=1.7","1.jpg");
ThreadPractice t2 = new ThreadPractice("https://tse2-mm.cn.bing.net/th/id/OIP-C.xsA-3qUw6cqmd8nRfxk6TQHaEK?w=298&h=180&c=7&r=0&o=5&dpr=1.25&pid=1.7","2.jpg");
ThreadPractice t3 = new ThreadPractice("https://tse2-mm.cn.bing.net/th/id/OIP-C.xsA-3qUw6cqmd8nRfxk6TQHaEK?w=298&h=180&c=7&r=0&o=5&dpr=1.25&pid=1.7","3.jpg");
t1.start();
t2.start();
t3.start();
}
}
//下载器
class WebDownloader{
//下载方法
public void downloader(String url,String name){
try {
FileUtils.copyURLToFile(new URL(url),new File(name));
} catch (IOException e) {
e.printStackTrace();
}
}
}
实现Runnable接口
package org.example;
//创建线程方式2：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
public class Thread3 implements Runnable {
@Override
public void run() {
//run方法线程体
for(int i=0;i<200;i++){
System.out.println("我在看代码--");
}
}
public static void main(String[] args){
//main线程，主线程
Thread3 thread3 = new Thread3();
Thread t = new Thread(thread3);
t.start();
for(int i=0;i<100;i++){
System.out.println("我在学习多线程--");
}
}
}
实现Callable接口
package org.example; import org.apache.commons.io.FileUtils; import java.io.File; import java.io.IOException; import java.net.URL; import java.util.concurrent.*; public class TestCallable implements CallableLambda表达式{ private String url;//网络图片地址 private String name;//保存的文件名 public TestCallable(String url,String name){ this.name = name; this.url = url; } //下载图片线程的执行体 public Boolean call() throws Exception { WebDownloader webDownloader = new WebDownloader(); webDownloader.downloader(url,name); System.out.println("下载了文件名为："+name); return true; } public static void main(String[] args) { TestCallable t1 = new TestCallable("https://tse2-mm.cn.bing.net/th/id/OIP-C.xsA-3qUw6cqmd8nRfxk6TQHaEK?w=298&h=180&c=7&r=0&o=5&dpr=1.25&pid=1.7","1.jpg"); TestCallable t2 = new TestCallable("https://tse2-mm.cn.bing.net/th/id/OIP-C.xsA-3qUw6cqmd8nRfxk6TQHaEK?w=298&h=180&c=7&r=0&o=5&dpr=1.25&pid=1.7","2.jpg"); TestCallable t3 = new TestCallable("https://tse2-mm.cn.bing.net/th/id/OIP-C.xsA-3qUw6cqmd8nRfxk6TQHaEK?w=298&h=180&c=7&r=0&o=5&dpr=1.25&pid=1.7","3.jpg"); //Callable线程实现步骤 //创建执行服务 ExecutorService ser = Executors.newFixedThreadPool(3); //提交执行 Future r1 = ser.submit(t1); Future r2 = ser.submit(t2); Future r3 = ser.submit(t3); //获取结果 try { boolean rs1 = r1.get(); boolean rs2 = r2.get(); boolean rs3 = r3.get(); } catch (Exception e) { e.printStackTrace(); } } } //下载器 class WebDownloader{ //下载方法 public void downloader(String url,String name){ try { FileUtils.copyURLToFile(new URL(url),new File(name)); } catch (IOException e) { e.printStackTrace(); } } }
**函数式接口的定义：**任何接口，如果只包含唯一一个抽象方法，那么就是一个函数式接口
对于函数式接口，可以通过lamda表达式来创建接口对象
package org.example;
public class TestLambda1 {
//3.静态内部类
static class Like2 implements ILike{
@Override
public void lambda() {
System.out.println("I like Lambda2");
}
}
public static void main( String[] args ) {
ILike like = new Like();
like.lambda();
like = new Like2();
like.lambda();
//4.局部内部类
class Like3 implements ILike{
@Override
public void lambda() {
System.out.println("I like Lambda3");
}
}
like = new Like3();
like.lambda();
//5.匿名内部类，没有类的名称，必须借助接口或者父类
like = new ILike() {
@Override
public void lambda() {
System.out.println("I like Lambda4");
}
};
like.lambda();
//6.用lambda简化
like = ()->{
System.out.println("I like lambda5");
};
like.lambda();
}
}
//1.定义一个函数式接口
interface ILike{
void lambda();
}
//2.实现类
class Like implements ILike{
@Override
public void lambda() {
System.out.println("I like lambda");
}
}
lambda简化
package org.example;
public class TestLambda2 {
public static void main(String[] args) {
//1.lambda表达式简化
ILove love = (int a)->{
System.out.println("I love you"+a);
};
//2.简化：去掉参数类型
love = (a) -> {
System.out.println("I love you "+a);
};
//3.简化：去掉小括号
love = a -> {
System.out.println("I love you "+a);
};
//4.简化：去掉花括号
love = a -> System.out.println("I love you "+a);
love.love(521);
}
}
interface ILove{
void love(int a);
}
总结：
lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹
前提是接口为函数接口，即只有一个抽象方法
多个参数也可以去掉参数类型，但是要去掉就都去掉，还需要小括号
wait/sleep同步块：synchronized**(Obj){}**
Obj称之为同步监视器
同步监视器的执行过程
setPriority(int newPriority) 更改线程的优先级
static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠
void join() 等待该线程终止
static void yield() 暂停当前正在执行的线程对象，并执行其他线程
void interrupt() 中断线程，尽量不要用
boolean isAlive() 测试线程是否处于活动状态
线程的停止不推荐JDK提供的stop()和destroy()方法，已废弃
建议线程自己停止下来（使用一个标志位进行终止变量，当flag=false，终止线程运行）
package org.example;
public class TestStop implements Runnable{
//设置一个标志位
private boolean flag = true;
@Override
public void run() {
int i = 0;
while(flag){
System.out.println("线程运行中"+i);
}
}
//设置一个公开的方法停止线程，转换标志位
public void stop(){
this.flag = false;
}
public static void main(String[] args) {
TestStop testStop = new TestStop();
new Thread(testStop).start();
for (int i = 0; i < 1000; i++) {
System.out.println("main"+i);
if(i==900){
//调用stop方法切换标志位，让线程停止
testStop.stop();
System.out.println("线程停止了");
}
}
}
}
线程休眠sleep
sleep指当前线程阻塞的毫秒数
sleep存在异常InterruptedException
sleep时间达到后线程进入就绪状态
sleep可以模拟网络延时，倒计时
每一个对象都有一个锁，sleep不会释放锁
企业中用JUC休眠
TimeUnit.DAYS.sleep() TimeUnit.SECONDS.sleep();
模拟延时：
package org.example;
public class TestSleep implements Runnable{
//票数
private int ticketNums = 10;
@Override
public void run() {
while(true){
if(ticketNums<=1){
break;
}
try {
//模拟延时
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"张票");
}
}
public static void main(String[] args) {
TestSleep ticket = new TestSleep();
new Thread(ticket,"小明").start();
new Thread(ticket,"小桑").start();
new Thread(ticket,"园园").start();
}
}
模拟倒计时：
package org.example;
public class TestSleep2{
//模拟倒计时
public static void tenDown() throws InterruptedException{
int num = 10;
while(true){
Thread.sleep(1000);
System.out.println(num--);
if(num<=0){
break;
}
}
}
public static void main(String[] args) {
try {
tenDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
线程礼让yield
礼让线程，让当前正在执行的线程暂停，但不阻塞
将线程从运行状态转为就绪状态
让CPU重新调度，礼让不一定成功，看CPU心情
package org.example;
public class TestYield {
public static void main(String[] args) {
MyYield myYield = new MyYield();
new Thread(myYield,"a").start();
new Thread(myYield,"b").start();
}
}
class MyYield implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程执行开始");
Thread.yield();//礼让
System.out.println(Thread.currentThread().getName()+"线程执行结束");
}
}
线程合并join
package org.example;
//测试Join，想象成插队
public class TestJoin implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("线程VIP来了"+i);
}
}
public static void main(String[] args) throws InterruptedException {
//我们的线程启动
TestJoin testJoin = new TestJoin();
Thread thread = new Thread(testJoin);
//主线程
for (int i = 0; i < 1000; i++) {
if(i==200){
thread.start();
thread.join();//插队
}
System.out.println("main"+i);
}
}
}
观测线程状态
package org.example;
public class TestState {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("结束了");
});
//观察状态
Thread.State state = thread.getState();
System.out.println(state);//NEW
//观察启动后
thread.start();//启动线程
state = thread.getState();
System.out.println(state);//Run
while(state!=Thread.State.TERMINATED){//只要线程不终止，就一直输出状态
Thread.sleep(100);
state = thread.getState();//更新线程状态
System.out.println(state);
}
}
}
线程优先级
java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，
线程调度器按照优先级决定应该调度那个线程来执行
线程的优先级用数字表示，范围从1-10
Thread.MIN_PRIORITY = 1;
Thread.MAX_PRIORITY = 10;
Thread.NORM_PRIORITY = 5;
可以使用getPriority()获取优先级，setPriority(int xxx)设置优先级，默认优先级都是5
package org.example;
//测试线程优先级
public class TestPriority extends Thread{
public static void main(String[] args) {
//主线程默认优先级
System.out.println(Thread.currentThread().getName()+"优先级："+Thread.currentThread().getPriority());
MyPriority myPriority = new MyPriority();
Thread t1 = new Thread(myPriority,"a");
Thread t2 = new Thread(myPriority,"b");
Thread t3 = new Thread(myPriority,"c");
Thread t4 = new Thread(myPriority,"d");
Thread t5 = new Thread(myPriority,"e");
//先设置优先级，再启动
t1.start();
t2.setPriority(1);
t2.start();
t3.setPriority(4);
t3.start();
t4.setPriority(10);
t4.start();
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"优先级："+Thread.currentThread().getPriority());
}
}
守护线程daemon
线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕
package org.example;
public class TestDaemon {
public static void main(String[] args) {
God god = new God();
You you = new You();
Thread t1 = new Thread(god);
t1.setDaemon(true);//默认false是用户线程，改成true变成守护线程
t1.start();
new Thread(you).start();//you 用户线程启动
}
}
class God implements Runnable{
@Override
public void run() {
while(true){
System.out.println("上帝保佑着你");
}
}
}
class You implements Runnable{
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println("我还活着");
}
System.out.println("==我死了，拜拜世界==");
}
}
线程同步
并发：同一个对象被多个线程同时操作
线程同步：队列+锁，就是一种等待机制
由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题
为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，
当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可，
线程同步存在的问题：
package org.example;
//线程不安全
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket,"可爱的小桑").start();;
new Thread(buyTicket,"帅气的园园").start();
new Thread(buyTicket,"掉线的月老").start();
}
}
class BuyTicket implements Runnable{
//票
private int ticketNums = 10;
boolean flag = true;//线程停止标志位
@Override
public void run() {
//买票
while(flag){
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//买票方法
private void buy() throws InterruptedException {
//判断是否有票
if(ticketNums<=0){
flag = false;
return;
}
Thread.sleep(100);
System.out.println(Thread.currentThread().getName()+"买到第"+ticketNums--+"张票了");
}
}
不安全取钱
package org.example;
//不安全的取钱
public class UnsafeBank {
public static void main(String[] args) {
//账户
Account account = new Account(10000,"共同存的钱");
Drawing lpy = new Drawing(account,5000,"李朋园");
Drawing slh = new Drawing(account,10000,"桑兰桦");
lpy.start();
slh.start();
}
}
//账户
class Account{
int balance;//卡内余额
String name;//卡号
public Account(int balance, String name) {
this.balance = balance;
this.name = name;
}
}
//银行：模拟取款
class Drawing extends Thread{
Account account;//账户
//取钱的金额
int drawingMoney;
//现金余额
int nowMoney;
public Drawing(Account account,int drawingMoney,String name){
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
//取钱
public void run() {
if(account.balance-drawingMoney<0){
System.out.println(Thread.currentThread().getName()+"的卡内余额不足");
return;
}
//sleep放大问题的发生性
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额=卡内余额-取的钱
account.balance = account.balance-drawingMoney;
//现金余额=现金余额+取的钱
nowMoney = nowMoney + drawingMoney;
System.out.println(account.name+"卡内余额为："+account.balance);
System.out.println(this.getName()+"现金余额为："+nowMoney);
}
}
不安全集合
package org.example;
import java.util.ArrayList;
import java.util.List;
public class UnsafeList {
public static void main(String[] args) {
List list = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
安全集合
手动安全
package org.example;
import java.util.ArrayList;
import java.util.List;
public class UnsafeList {
public static void main(String[] args) {
List list = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
synchronized (list){
list.add(Thread.currentThread().getName());
}
}).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
JUC自带安全集合：
CopyOnWriteArrayList
package org.example;
import java.util.concurrent.CopyOnWriteArrayList;
public class TestJUC {
public static void main(String[] args) {
CopyOnWriteArrayList list = new CopyOnWriteArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
锁
死锁
死锁形成的四个必要条件：
破坏以上任意一个或多个条件，就可避免死锁
package org.example;
//死锁：多个线程互相抱着对方需要的资源，形成僵持
public class DeadLock {
public static void main(String[] args) {
Makeup g1 = new Makeup(0,"桑兰桦");
Makeup g2 = new Makeup(1,"梁子怡");
g1.start();
g2.start();
}
}
//口红
class Lipstick{
}
//镜子
class Mirror{
}
//化妆
class Makeup extends Thread{
//化妆需要的口红镜子资源，用static保证只有一份
static Lipstick lipstick = new Lipstick();
static Mirror mirror = new Mirror();
int choice;//选择
String girlName;//化妆的人
public Makeup(int choice, String girlName) {
this.choice = choice;
this.girlName = girlName;
}
public void run() {
//化妆
try {
makeup();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//化妆的方法
private void makeup() throws InterruptedException {
if(choice==0){
synchronized (lipstick){
System.out.println(this.girlName+"获得口红的锁");
Thread.sleep(1000);
synchronized (mirror){
System.out.println(this.girlName+"获得镜子的锁");
}
}
}else {
synchronized (mirror){
System.out.println(this.girlName+"获得镜子的锁");
Thread.sleep(2000);
synchronized (lipstick){
System.out.println(this.girlName+"获得口红的锁");
}
}
}
}
}
Lock锁
◆ 从JDK 5.0开始，Java提供了线程同步机制，通过显式定义同步锁对象来实现同步，同步锁使用Lock对象充当
◆ java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。
锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，
线程开始访问共享资源之前应先获得Lock对象
◆ 可重入锁，ReentrantLock类实现了Lock ，它拥有与synchronized相同的并发性和内存语义，
在实现线程安全的控制中，比较常用的是ReentrantLock,可以显式加锁、释放锁
package org.example;
import java.util.concurrent.locks.ReentrantLock;
public class TestLock {
public static void main(String[] args) {
TestLock2 testLock2 = new TestLock2();
new Thread(testLock2).start();
new Thread(testLock2).start();
new Thread(testLock2).start();
}
}
class TestLock2 implements Runnable {
int ticketNums = 10;
//定义Lock锁
private final ReentrantLock lock = new ReentrantLock();
public void run() {
while(true){
try{
//加锁
lock.lock();
if(ticketNums>0){
Thread.sleep(1000);
System.out.println(ticketNums--);
}else {
break;
}
}catch (InterruptedException e) {
e.printStackTrace();
}finally {
//解锁
lock.unlock();
}
}
}
}
线程池初识
◆ 背景:经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
◆ 思路:提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。
可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
◆好处:
◆ JDK 5.0起提供了线程池相关API，ExecutorService 和Executors
◆ExecutorService: 真正的线程池接口。常见子类ThreadPoolExecutor
◆void execute(Runnable command) :执行任务/命令,没有返回值，一般用来执行Runnable
◆ Future submit(Callable task):执行任务，有返回值，一般用来执行Callable
◆void shutdown() :关闭连接池
◆Executors:工具类、线程池的工厂类,用于创建并返回不同类型的线程池
package org.example;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//测试线程池
public class TestPool {
public static void main(String[] args) {
//1.创建线程池，参数为线程池的大小
ExecutorService service = Executors.newFixedThreadPool(10);
//2.执行
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
//3.关闭连接
service.shutdown();
}
}
class MyThread implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
JUC基础
JUC实际就是java.util.concurrent工具包、类
java.util.concurrent.atomic
java.util.concurrent.locks
并发和并行并发（多线程操作一个资源）：一个CPU交替执行多个线程（单核，速度快）
并行：多个CUP同时执行多个线程（多核）
public class Test1{
public static void main(String[] args) {
//获取CPU的核数
System.out.println(Runtime.getRuntime().availableProcessors());
}
}
并发编程的本质：充分利用CPU的资源
线程的状态//创建 NEW, //运行 RUNNABLE, //阻塞 blocked BLOCKED, //死死地等 WAITING, //超时等待（等到时间就不等了） TIMED_WAITING, //terminated,终止 TERMINATEDwait和sleep的区别
package org.example;
public class SaleTicket {
public static void main(String[] args) {
Ticket ticket = new Ticket();
new Thread(()->{
for(int i=0;i<60;i++){
ticket.sale();
}
},"A").start();
new Thread(()->{
for(int i=0;i<60;i++){
ticket.sale();
}
},"B").start();
new Thread(()->{
for(int i=0;i<60;i++){
ticket.sale();
}
},"C").start();
}
}
//OOP，降低耦合性
class Ticket{
private int number = 50;
//买票方法
public synchronized void sale(){
if(number>0){
System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"张票");
}
}
}
LOCK接口
//加锁
Lock l = ...;
l.lock();
//解锁
l.unlock();
//可重入锁
ReentrantLock:原码有两个构造方法
public ReentrantLock() {
sync = new NonfairSync();//非公平锁
}
public ReentrantLock(boolean fair) {
//fair为true是公平锁，fair为false是非公平锁
sync = fair ? new FairSync() : new NonfairSync();
}
公平锁：十分公平（先来后到）
非公平锁：十分不公平（可以插队，默认是非公平锁）
package org.example;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SaleTicket {
public static void main(String[] args) {
Ticket ticket = new Ticket();
new Thread(()->{for(int i=0;i<60;i++) ticket.sale();},"A").start();
new Thread(()->{for(int i=0;i<60;i++) ticket.sale();},"B").start();
new Thread(()->{for(int i=0;i<60;i++) ticket.sale();},"C").start();
}
}
//OOP，降低耦合性
class Ticket{
//Lock三部曲
//1.new ReentrantLock();
//2.加锁，lock.lock();
//3.解锁，lock.unlock();
private int number = 50;
Lock lock = new ReentrantLock();
//买票方法
public void sale(){
lock.lock();//加锁
lock.tryLock();//尝试锁
try{
if(number>0){
System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"张票");
}
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
synchronzied与Lock区别
synchronized是内置的java关键字，Lock是一个java类
synchronized无法判断获取锁的状态，Lock可以判断是否获取到了锁
synchronized会自动释放锁，Lock必须要手动释放锁，否则会死锁
synchronized的线程会傻傻的等待，Lock不一定会等待下去
synchronized的可重入锁，不可以中断的，非公平的。
Lock的可重入锁，可以判断锁，非公平（可以自己设置）
synchronized适合少量的代码同步问题，Lock适合锁大量的同步代码
| sleep() | wait() | |
|---|---|---|
| 类 | Thread类 | Object类 |
| 调用 | 类名. | 对象. |
| 理解 | 哪个位置调用，哪个线程等待 | 对象调用方法，访问对象的其他线程等待 |
| 唤醒 | 不需要别人唤醒 | 需要其他对象调用notify唤醒 |
| 锁 | 不会释放锁 | 等待后会释放锁 |
package org.example;
public class PC {
public static void main(String[] args) {
Data data = new Data();
new Thread(()->{
try {
for (int i = 0; i < 10; i++) {
data.increment();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
},"A").start();
new Thread(()->{
try {
for (int i = 0; i < 10; i++) {
data.decrement();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
},"B").start();
}
}
//数字 资源类
//判断等待 业务 通知
class Data{
private int number = 0 ;
//+1
public synchronized void increment() throws InterruptedException {
if (number!=0){
//访问 调用increment()方法的data 的那个线程进入等待
this.wait();
}
number++;
System.out.println(Thread.currentThread().getName()+"==>"+number);
//唤醒所有线程
this.notifyAll();
}
//-1
public synchronized void decrement() throws InterruptedException {
if (number==0){
//等待
this.wait();
}
number--;
System.out.println(Thread.currentThread().getName()+"==>"+number);
this.notifyAll();
}
}
如果有多个生产者和消费者线程，会怎样？ 虚假唤醒
虚假唤醒,多个生产者消费者只需把if换成while
package org.example;
public class PC {
public static void main(String[] args) {
Data data = new Data();
new Thread(()->{
try {
for (int i = 0; i < 10; i++) {
data.increment();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
},"A").start();
new Thread(()->{
try {
for (int i = 0; i < 10; i++) {
data.increment();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
},"C").start();
new Thread(()->{
try {
for (int i = 0; i < 10; i++) {
data.decrement();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
},"B").start();
new Thread(()->{
try {
for (int i = 0; i < 10; i++) {
data.decrement();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
},"D").start();
}
}
//数字 资源类
//判断等待 业务 通知
class Data{
private int number = 0 ;
//+1
public synchronized void increment() throws InterruptedException {
while (number!=0){
//访问 调用increment()方法的data 的那个线程进入等待
this.wait();
}
number++;
System.out.println(Thread.currentThread().getName()+"==>"+number);
//唤醒所有线程
this.notifyAll();
}
//-1
public synchronized void decrement() throws InterruptedException {
while (number==0){
//等待
this.wait();
}
number--;
System.out.println(Thread.currentThread().getName()+"==>"+number);
this.notifyAll();
}
}
JUC生产者消费者
Java.util.concurrent.locks的三个接口：Condition、Lock、ReadWriteLock
使用Lock替代synchronized
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
condition.await()替代wait();
condition.signalAll()替代notifyAll();
package org.example;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//数字 资源类
//判断等待 业务 通知
class Data{
private int number = 0 ;
//使用Lock替换synchronized
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
//+1
public void increment() throws InterruptedException {
lock.lock();//加锁
try{
//业务代码
while (number!=0){
//访问 调用increment()方法的data 的那个线程进入等待
condition.await();
}
number++;
System.out.println(Thread.currentThread().getName()+"==>"+number);
//唤醒所有线程
condition.signalAll();
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();//解锁
}
}
//-1
public void decrement() throws InterruptedException {
lock.lock();
try {
while (number==0){
//等待
condition.await();
}
number--;
System.out.println(Thread.currentThread().getName()+"==>"+number);
//唤醒
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
以上代码，线程的执行顺序是随机的
为了做到先执行A线程，然后通知B线程，在通知C线程，最后通知D线程执行
需要：
Condition精准通知与唤醒同步监视器
package org.example;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class TestCondition {
public static void main(String[] args) {
Data1 data1 = new Data1();
new Thread(()->{for(int i=0;i<10;i++)data1.printA();},"A").start();
new Thread(()->{for(int i=0;i<10;i++)data1.printB();},"B").start();
new Thread(()->{for(int i=0;i<10;i++)data1.printC();},"C").start();
}
}
class Data1{//资源类 使用Lock
private int number = 1;
private Lock lock = new ReentrantLock();
private Condition condition1 = lock.newCondition();
private Condition condition2 = lock.newCondition();
private Condition condition3 = lock.newCondition();
public void printA(){
lock.lock();//加锁
try {
//判断等待 业务 唤醒
while (number!=1){
condition1.await();
}
System.out.println(Thread.currentThread().getName()+"==>我是A线程");
number = 2;
//唤醒指定的线程
condition2.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printB(){
lock.lock();
try {
while(number!=2){
condition2.await();
}
System.out.println(Thread.currentThread().getName()+"==>我是B线程");
number = 3;
condition3.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printC(){
lock.lock();
try {
while(number!=3){
condition3.await();
}
System.out.println(Thread.currentThread().getName()+"==>我是B线程");
number = 1;
condition1.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
8锁现象-重点
关于锁的八个问题：
public class Test1 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{phone.sendMessage();},"A").start();
try {
TimeUnit.SECONDS.sleep(1);//延迟1秒
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{phone.call();},"B").start();
}
}
class Phone{
public synchronized void sendMessage(){
//try {
// TimeUnit.SECONDS.sleep(4);//延迟4秒
//} catch (InterruptedException e) {
// e.printStackTrace();
//}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
以上代码运行，是先输出发短信，还是先输出打电话？
结果：先输出发短信，再输出打电话
原因：有锁的存在，phone对象是同一个，谁先拿到phone，谁锁住它
以上代码发短信的方法加入4秒延迟，输出顺序又如何？
结果：依旧是先输出发短信，后输出打电话
原因：由于锁的缘故（并不是由于先调用先执行），synchronized被锁的对象是调用者，即phone对象， 两个方法用的是同一个锁–phone对象，发短信先拿到的锁发短信线程先执行
将以上代码打电话方法的synchronized删掉，即call()变成一个普通方法，输出顺序又如何？
结果：先输出打电话，后输出发短信
原因：call()不再受锁的影响了
将以上代码增加一个phone对象，让phone1发短信，phone2打电话，输出结果又如何？
结果：先输出打电话，后输出发短信
原因：两个phone对象，按照代码情况各执行各的，1秒后输出打电话，4秒后输出发短信
两个phone对象，将sendMessage()方法和call()方法都加上static修饰，输出结果如何？
public class Test2 {
public static void main(String[] args) {
Phone2 phone1 = new Phone2();
Phone2 phone2 = new Phone2();
new Thread(()->{phone1.sendMessage();},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{phone2.call();},"B").start();
}
}
class Phone2{
public static synchronized void sendMessage(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public static synchronized void call(){
System.out.println("打电话");
}
}
结果：先输出发短信，后输出打电话
原因：加入static修饰，类一加载就有了，synchronized锁定的是Phone2的类模板Class，只有一份
谁先得到锁，谁先执行
两个phone对象，sendMessage()用static修饰，call()不用static修饰，输出结果又如何？
结果：先输出打电话，后输出发短信
原因：锁的不再是一个对象，一个锁的Phone的Class，一个锁的是phone2,各执行各的
如果是一个phone对象，sendMessage()被static synchronized修饰，call()只被synchronized修饰，
输出结果又会怎样？
结果：先输出打电话，后输出发短信
原因：锁的不再是一个对象，一个锁的Phone的Class，一个锁的是phone,各执行各的
锁只会锁 对象 和 Class
new --> this具体的一个手机
static --> Class唯一的一个模板
集合类不安全 List不安全CopyOnWrite：写入时复制，COW思想
多个线程调用的时候，读取固定，写入可能存在覆盖操作
COW思想，就是在写入的时候复制一份，避免覆盖造成数据问题
List list = new CopyOnWriteArrayList<>();
使用CopyOnWriteArrayList比用Vector的优势：没有使用synchronized修饰，使用的Lock锁，效率更高
在并发下，ArrayList不安全：(以下代码使用ArrayList会报异常)
会报异常：java.util.ConcurrentModificationException，并发修改异常
解决方案：
//ListSet不安全list = new ArrayList<>(); //List list = new Vector<>(); //List list = Collections.synchronizedList(new ArrayList<>()); List list = new CopyOnWriteArrayList<>(); for (int i = 1; i <= 10; i++) { new Thread(()->{ list.add(UUID.randomUUID().toString().substring(0,5)); System.out.println(list); },String.valueOf(i)).start(); }
Set set = new CopyOnWriteArraySet();
//会报异常：java.util.ConcurrentModificationException，并发修改异常 //Setset = new HashSet<>(); //Set set = Collections.synchronizedSet(new HashSet<>()); Set set = new CopyOnWriteArraySet(); for (int i = 1; i <= 10 ; i++) { new Thread(()->{ set.add(UUID.randomUUID().toString().substring(0,5)); System.out.println(set); },String.valueOf(i)).start(); }
HashSet底层就是HashMap：
Set本质就是Map的key,因为key是无重复的
public HashSet() {
map = new HashMap<>();
}
//add方法
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
//PRESENT,一个不变的值
private static final Object PRESENT = new Object();
Map不安全
回顾Map的基本操作：
