线程JavaSE
线程简介
-
Process与Thread
-
程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念
-
进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
-
通常在一个进程中可以包若干个线程，当然一个进程中至少有一个线程，不然没有存在意义。线程是CPU调度和执行的单位
-
-
本章核心概念
-
线程就是独立运行的执行路径
-
在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，
gc线程 -
main()称之为主线程，为系统的入口，用于执行整个程序 -
在一个进程中如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统密切相关的，先后顺序是不能人为干预的
-
线程会带来额外的开销，如
cpu调度时间，并发控制开销 -
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致
-
线程实现（重点）
三种创建方式
-
继承
Thread类-----Thread class(重点) -
实现
Runnable接口(重点) -
实现Callable接口(了解)
-
Thread （不建议使用：避免OOP单继承局限性）
-
自定义线程类继承Thread类
-
重写
run()方法，编写线程执行体 -
创建线程对象，调用
start()方法启动线程
-
public class TestThread1 extends Thread {
//线程切入点
注意：线程开启不一定立即执行，由CPU调度执行
-
实现
Runnable(推荐使用，因为Java单继承的局限性，方便一个对象被多个线程使用 )-
定义
MyRunnable类实现Runnable接口 -
实现
run()方法，编写线程执行体 -
创建线程对象，调用
start()方法启动线程
-
public class TestThread3 implements Runnable{
-
实现
Callable接口（了解）-
实现
Callable接口，需要抛出返回值类型 -
重写call方法，需要抛出异常
-
创建目标对象
-
创建执行服务：
ExecutorService ser = Executor.newFixedThreadPoo;(1); -
提交执行：
Future<Boolean> result1 = ser.submit(t1); -
获取结果：
boolean r1 = result1.get(); -
关闭服务：
ser.shutdownnNow();
-
静态代理模式
-
静态代理模式总结：
-
真实对象和代理对象都要实现同一个接口
-
代理对象要代理真实角色
-
-
好处：
-
代理对象可以做很多真实对象做不了的事情
-
真实对象专注做自己的事情
-
public class StarticProxy {
WeddingCompany weddingCompany = new WeddingCompany(new You());
weddingCompany.HappyMarry();
}
interface Marry{
void HappyMarry();
}
//真实角色，你去结婚
class You implements Marry{
Lamda表达式
-
为什么要使用lambda表达式
-
避免匿名内部类定义过多
-
可以让你的代码看起来更简洁
-
去掉了一堆没有意义的代码只留下核心 的逻辑
-
-
λ希腊字母标中排序第十一为的字母，英语名称为Lambda
-
其实值属于函数式编程的概念
(params) -> expression [表达式]
(params) -> statement [语句]
(params) -> {statements}
a->System.out.println("i like lambda-->"+a);
new Thread (()->System.out.println("多线程学习.")).start();
-
逐步简化
/*
推导lambda表达式
*/
public class TestLambda1 {
//3.静态内部类
static class Like2 implements ILike{
public class TestLambda2 {
public static void main(String[] args) {
//1.lambda表示简化
ILove love = (int a)->{
System.out.println("i love you--->"+a);
};
//简化1，参数类型
love = (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);
love.love(2);
}
}
interface ILove{
void love(int a);
}
//总结：
//lambda表达式只能有一行代码的情况下才能简化为一行，如果有多行，那么就用代码块包裹
//前提是接口为函数式接口（接口只有一个函数）
//多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号
线程状态
-
创建状态（new）
-
Thread = new Thread()线程对象一旦创建就进入到了新生状态
-
-
就绪状态
-
当调用
start()方法，线程立即进入就绪状态，但不意味着立即调度执行
-
-
运行状态
-
被系统调度后，静茹运行状态，线程才真正执行线程体的代码块
-
-
阻塞状态
-
当调用sleep，wait或同步锁定时，线程进入阻塞状态，就是代码不往下执行，阻塞事件解除后，重新进入就绪状态，等待cpu调度执行
-
-
死亡状态（dead）
-
线程中断或者结束，一旦进入死亡状态，就不能再次启动
-
-
线程方法
-
停止线程
-
不推荐使用JDK提供
stop()、destory()方法【已经废弃】 -
推荐线程自己停止下来
-
建议使用一个标志位进行终止变量，当flag = false，则终止线程运行
-
建议线程正常停止
--->利用次数，不建议死循环
-
//测试stop
public class TestStop implements Runnable{
//1.设置一个标识位
private boolean flag = true;
@Override
public void run() {
int i = 0;
while (flag){
System.out.println("run...Thread"+i++);
}
}
//2.设置一个公开的方法停止线程，转换标志位
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存在异常InterrupterdException -
sleep时间达到后线程进入就绪状态 -
sleep可以模拟网络延时，倒计时等 -
每一个对象都有一个锁，
sleep不会释放锁
-
//模拟倒计时
public class TestSleep {
public static void main(String[] args) {
try {
tenDow();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void tenDow() throws InterruptedException{
int num = 10;
while(true){
Thread.sleep(1000);
System.out.println(num--);
if (num <= 0){
break;
}
}
}
}-
线程礼让
-
礼让线程，让当前正在执行的线程暂停，但不阻塞
-
将线程重运行状态转为就绪状态
-
让CPU重新调度，礼让不一定成功，看CPU心情
-
//线程礼让 即重新调度，礼让不一定成功
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{
-
Join
-
Join合并线程，待此线程执行完成后，再执行其他线程，其它线程阻塞
-
可以想象成插队
-
-
public class TestJoin implements Runnable{
-
线程状态观测
-
Thread.Stade-
NEW 尚未启动的线程处于此状态
-
RUNNABLE 在Java虚拟机中执行的线程处于此状态
-
BLOCKED 被阻塞等待监视器锁定的线程处于此状态
-
WAITING 正在等待另一个线程执行特定动作的线程处于此状态
-
TIME_WAITING正在等待另一个线程到达指定等待时间的线程处于此状态
-
TERMINATED 已退出的线程处于此状态
-
//观察测试线程的状态
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)
-
-
//测试线程的优先级
public class TestPriority {
public static void main(String[] args) {
//主线程默认优先级
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
MyPriority myPriority = new MyPriority();
Thread t1 = new Thread(myPriority);
Thread t2 = new Thread(myPriority);
Thread t3 = new Thread(myPriority);
Thread t4 = new Thread(myPriority);
//设置优先级
t1.start();
t2.setPriority(1);
t2.start();
t3.setPriority(4);
t3.start();
t4.setPriority(Thread.MAX_PRIORITY);
t4.start();
}
}
class MyPriority implements Runnable{
-
守护线程
-
线程分为用户线程和守护线程
-
虚拟机必须保护用户线程执行完毕
-
虚拟 机不用等待守护线程执行完毕
-
如，后台记录操作日志，监控内存，垃圾回收等待...
-
//测试守护线程
//上帝保护你
public class TestDaemon {
public static void main(String[] args) {
God god = new God();
You you = new You();
Thread thread = new Thread(god);
thread.setDaemon(true);//默认是false表示是用户线程，正常的线程都是用户线程...
thread.start();//上帝线程启动
new Thread(you).start();//你 用户线程启动...
}
}
//上帝
class God implements Runnable {
线程同步
-
定义：多个线程操作同一个资源
-
并发：同一个对象被多个线程同时操作
-
-
由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制
synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题：-
一个线程持有锁会导致其它所有需要此锁我线程挂起
-
在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
-
如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置引起性能问题
-
-
同步方法
-
由于我们可以通过
private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，包括两种用法：synchronized方法和synchronized块
//同步方法
public synchronized void method(int args){}-
synchronized控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行（缺陷：若将一个大的方法声明为synchronized将会影响效率）
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket station = new BuyTicket();
new Thread(station,"苦逼的我").start();
new Thread(station,"牛逼的你们").start();
new Thread(station,"可恶的黄牛党").start();
}
}
class BuyTicket implements Runnable{
//票
private int ticketNums = 10;
boolean flag = true;//外部停止方式
-
同步方法弊端
-
方法里面需要修改的内容才需要锁，锁的太多，浪费资源
-
-
-
同步块
-
同步块：
synchronized(Obj) {}
-
-
Obj称之为同步监视器-
Obj可以说任何对象，但是推荐使用共享资源作为同步监视器 -
同步方法中无需指定同步监视器，因为同步方法的同步监视器就是
this，就是这个对象本身，或者是class
-
-
同步监视器的执行过程
-
第一个线程访问，锁定同步监视器，执行其中代码
-
第二个线程访问，发现同步监视器被锁定，无法访问
-
第一个线程访问完毕，解锁同步监视器
-
第二个线程访问，发现同步监视器没有锁，然后锁定访问
-
//线程不安全的集合
public class UnsafeList {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
for (int i = 0; i < 100000; i++) {
new Thread(()->{
synchronized (list){//同步块
list.add(Thread.currentThread().getName());
}
}).start();
}
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
//JUC安全类集合 CoplyOnWriteArraryLlist
//CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
死锁
-
多个线程各自站有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都，在等待对方释放资源，都停止执行的情形。某一同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题
-
死锁避免方法
-
产生死锁的四个必要条件
-
互斥条件：一个资源每次只能被一个进程使用
-
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
-
不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
-
循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
-
-
上面列出了死锁的四个必要条件，只要想办法破坏其中的任意一个或多个条件就可以避免死锁发生
-
//死锁：多个线程互相抱着对方需要的资源，然后形成僵持
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;//使用化妆品的人
Makeup(int choice,String girlName){
this.choice = choice;
this.girlName = girlName;
}
Lock（锁）
class A{
private final ReentrantLock lock = new ReenTrantLock();
public void m(){
lock.lock();
try{
//保证线程安全的代码
}
finally{
lock.unlock();
//如果同步代码有异常，要将unlock()写入finally语句块
}
}
}
-
从JDK5.0开始，Java提供了更强大的线程同步机制---------通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
-
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象枷锁，线程开始访问共享资源之前应先获得Lock对象 -
ReentrantLock类实现了Lock，它拥有了与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁
//测试Lock锁
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 tickNums = 10;
//定义lock锁
private final ReentrantLock lock = new ReentrantLock();
-
synchronized与Lock的对比-
Lock是显式锁（手动开启和关闭锁，别忘记关闭锁）
synchronized是隐式锁，出了作用域和自动释放 -
Lock只有代码块锁，
synchronized有代码块锁和方法锁 -
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
-
优先使用顺序
-
Lock > 同步代码块（已经进入了方法体，分配了相应资源）> （在方法体之外）
-
-
线程通信问题（重点）
-
应用场景：生产者和消费者问题
-
假设厂库中只能存放一件产品，生产者将生产出来的产品放入厂库，消费者将仓库中产品取走消费
-
如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止
-
如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，仓库中的产品被消费者取走为止
-
分析：这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间互相依赖，互为条件
-
-
-
线程通信
-
Java提供了几个方法解决线程之间的通信问题（Object类的方法）
wait() //表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
wait(long timeout) //指定等待的毫秒数
notify() //唤醒一个处于等待状态的线程
notifyAll() //唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度 -
-
解决方式1：
-
并发协作模型”生产者、消费者模式“---->管程法
-
生产者：负责生产数据的模块（可能是方法，对象，线程，进程）
-
消费者：负责处理数据的模块（可能是方法，对象，线程，进程）
-
缓冲区：消费者不能直接使用生产者的数据，他们之间有个”缓冲区“
-
-
生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据
-
//测试：生产者消费者模型-->利用缓冲区解决：管程法
//生产者，消费者，产品，缓冲区
public class TestPC {
public static void main(String[] args) {
SynContainer container = new SynContainer();
new Producer(container).start();
new Consumer(container).start();
}
}
//生产者
class Producer extends Thread{
SynContainer container;
public Producer(SynContainer container){
this.container = container;
}
//生产