多线程

多线程的原理

 

多线程的内存图解

 

Thread类获取线程名称

获取线程的名称：

1.使用Thread类中的方法getName()

String getName()返回该线程的名称。

2.可以获取到当前正在执行的线程，使用线程中的方法getName()获取线程的名称

static Thread currentThread()返回对当前正在执行的线程对象的引用。

 

Thread类设置线程的名称

设置线程的名称：（了解）

    1.使用Thread类中的方法setName（名字）

    2.创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法，把线程名称传递给父类，让父类(Thread)给子线程取名Thread(String name)分配的Thread对象。

 

Thread类sleep方法

public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）

毫秒数结束之后，线程继续执行 

 

创建多线程的第一种方式-创建Thread类的子类

创建多线程程序的第一种方式:创建Thread类的子类

java.lang.Thread类:是描述线程的类,我们想要实现多线程程序,就必须继承Thread类

 

实现步骤:

1.创建一个Thread类的子类

2.在Thread类的子类中重写Thread类中的run方法,设置线程任务(开启线程要做什么?)

3.创建Thread类的子类对象

4.调用Thread类中的方法start方法,开启新的线程,执行run方法

void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

结果是两个线程并发地运行；当前线程（main线程）和另一个线程（创建的新线程,执行其 run 方法）。

多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。

java程序属于抢占式调度,那个线程的优先级高,那个线程优先执行;同一个优先级,随机选择一个执行

 

创建多线程的第二种方法-实现Runnable接口

创建多线程程序的第二种方式：实现Runnable接口

java.lang.Runnable

Runnable接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义为一个称为run的无参数方法。

java.lang.Thread的构造方法

Thread(Runnable target)分配新的Thread对象。

Thread(Runnable target，String name)分配新的Thread对象。

 

实现步骤：

1.创建一个Runnable接口的实现类

2.在实现类中重写Runnable接口的run方法，设置线程任务

3.创建一个Runnable接口的实现类对象

4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象

5.调用Thread类中的start方法，开始新的线程执行run方法

 

Thread和Runnable的区别

实现Runnable接口创建多线程程序的好处

    1.避免了单继承的局限性

        一个类只能继承一个类

        实现了Runnable接口，还可以继承其他的类，实现其他的接口。

    2.增强了程序的扩展性，降低了程序的耦合性（解耦）

        实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离（解耦）

        实现类中，重写了run方法：用来设置线程任务

        创建Thread类对象，调用start方法：用来开启新线程

 

并发与并行

 

匿名内部类方式实现线程的创建

匿名:没有名字

内部类:写在其他类内部的类

 

匿名内部类作用:简化代码

把子类继承父类,重写父类的方法,创建子类对象合一步完成

把实现类实现接口,重写接口中的方法,创建实现类对象合成一步完成

匿名内部类的最终产物:子类/实现类对象,而这个类没有名字

 

格式:

new 父类/接口(){

重写父类/接口中的方法

};

 

进程概念

 

线程概念

 

线程调度

 

主线程

 

主线程:执行主(main)方法的线程

 

单线程程序:java程序中只有一个线程

执行从main方法开始,从上到下依次执行

 

JVM执行main方法,main方法会进入到栈内存

JVM会找操作系统开辟一条main方法通向cpu的执行路径

cpu就可以通过这个路径来执行main方法

而这个路径有一个名字,叫main(主)线程

 

 

线程安全问题概述

 

线程安全问题的代码实现

/*

实现卖票案例

*/

public class RunnableImpl implements Runnable{

//定义一个多个线程共享的票源

private int ticket = 100;

 

 

//设置线程任务:卖票

@Override

public void run() {

//使用死循环,让卖票操作重复执行

while(true){

//先判断票是否存在

if(ticket>0){

//提高安全问题出现的概率,让程序睡眠，但仍有线程安全问题，会出现重复和-1

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

 

//票存在,卖票 ticket--

System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");

ticket--;

}

}

}

}

 

线程安全问题产生的原理

 

解决线程安全问题-同步代码块

卖票案例出现了线程安全问题

卖出了不存在的票和重复的票

 

解决线程安全问题的一种方案:使用同步代码块

格式:

synchronized(锁对象){

可能会出现线程安全问题的代码(访问了共享数据的代码)

}

 

注意:

1.同步代码块中的锁对象,可以使用任意的对象

2.但是必须保证多个线程使用的锁对象是同一个(创建在run（）方法外)

3.锁对象作用:

把同步代码块锁住,只让一个线程在同步代码块中执行

 

同步技术的原理

 

解决线程安全问题-同步方法

卖票案例出现了线程安全问题

卖出了不存在的票和重复的票

 

解决线程安全问题的二种方案:使用同步方法

使用步骤:

1.把访问了共享数据的代码抽取出来,放到一个方法中

2.在方法上添加synchronized修饰符

 

格式:定义方法的格式

修饰符 synchronized 返回值类型 方法名(参数列表){

可能会出现线程安全问题的代码(访问了共享数据的代码)

}

 

定义一个同步方法

同步方法也会把方法内部的代码锁住

只让一个线程执行

同步方法的锁对象是谁?

就是实现类对象 new RunnableImpl()

也是就是this

 

静态的同步方法

锁对象是谁?

不能是this

this是创建对象之后产生的,静态方法优先于对象

静态方法的锁对象是本类的class属性-->class文件对象(反射)

 

解决线程安全问题-Lock锁

卖票案例出现了线程安全问题

卖出了不存在的票和重复的票

 

解决线程安全问题的三种方案:使用Lock锁

java.util.concurrent.locks.Lock接口

Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。

Lock接口中的方法:

void lock()获取锁。

void unlock() 释放锁。

java.util.concurrent.locks.ReentrantLock implements Lock接口

 

 

使用步骤:

1.在成员位置创建一个ReentrantLock对象

2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁

3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁

 

线程间通信

概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同

 

等待唤醒机制概述

 

等待唤醒机制代码实现-包子类&包子铺

生产者(包子铺)类:是一个线程类,可以继承Thread

设置线程任务(run):生产包子

对包子的状态进行判断

true:有包子

包子铺调用wait方法进入等待状态

false:没有包子

包子铺生产包子

增加一些趣味性:交替生产两种包子

有两种状态(i%2==0)

包子铺生产好了包子

修改包子的状态为true有

唤醒吃货线程,让吃货线程吃包子

 

注意:

包子铺线程和包子线程关系-->通信(互斥)

必须同时同步技术保证两个线程只能有一个在执行

锁对象必须保证唯一,可以使用包子对象作为锁对象

包子铺类和吃货的类就需要把包子对象作为参数传递进来

1.需要在成员位置创建一个包子变量

2.使用带参数构造方法,为这个包子变量赋值

 

等待唤醒机制代码实现-吃货类

消费者(吃货)类:是一个线程类,可以继承Thread

设置线程任务(run):吃包子

对包子的状态进行判断

false:没有包子

吃货调用wait方法进入等待状态

true:有包子

吃货吃包子

吃货吃完包子

修改包子的状态为false没有

吃货唤醒包子铺线程,生产包子

 

main方法

测试类:

包含main方法,程序执行的入口,启动程序

创建包子对象;

创建包子铺线程,开启,生产包子;

创建吃货线程,开启,吃包子;

 

线程状态概述

等待唤醒案例分析

等待唤醒案例代码实现

等待唤醒案例:线程之间的通信

创建一个顾客线程(消费者):告知老板要的包子的种类和数量,调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)

创建一个老板线程(生产者):花了5秒做包子,做好包子之后,调用notify方法,唤醒顾客吃包子

 

注意:

顾客和老板线程必须使用同步代码块包裹起来,保证等待和唤醒只能有一个在执行

同步使用的锁对象必须保证唯一

只有锁对象才能调用wait和notify方法

 

Obejct类中的方法

void wait()

在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。

void notify()

唤醒在此对象监视器上等待的单个线程。

会继续执行wait方法之后的代码

 

Object类中wait带参方法和notifyAll方法

进入到TimeWaiting(计时等待)有两种方式

1.使用sleep(long m)方法,在毫秒值结束之后,线程睡醒进入到Runnable/Blocked状态

2.使用wait(long m)方法,wait方法如果在毫秒值结束之后,还没有被notify唤醒,就会自动醒来,线程睡醒进入到Runnable/Blocked状态

 

唤醒的方法:

void notify() 唤醒在此对象监视器上等待的单个线程。

void notifyAll() 唤醒在此对象监视器上等待的所有线程。