- 程序、进程、线程的概念
- Java中多线程的创建和使用
----Thread 类与实现 Runnable 接口
----Thread类的主要方法
----线程的调度与设置优先级 - 线程的生命周期
- 线程的同步
- 线程的通信
一、基本概念:程序 - 进程 - 线程
-
程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码,静态对象。
-
进程(process)是程序的一次执行过程,或是正在运行的一个程序。动态过程:有它自身的产生、存在和消亡的过程。
如:运行中的QQ,运行中的MP3播放器
程序是静态的,进程是动态的 -
线程(thread),进程可进一步细化为线程,是一个程序内部的一条执行路径。
若一个程序可同一时间执行多个线程,就是支持多线程的
何时需要多线程
- 程序需要同时执行两个或多个任务。
- 程序需要实现一些需要等待的任务时,如用户输入、文件读写操作、网络操作、搜索等。
- 需要一些后台运行的程序时。
二、线程的创建和启动
public class Sample {
public void method1(String str){
System.out.println(str);
}
public void method2(String str){
method1(str);
}
public static void main(String[] args) {
Sample s = new Sample();
s.method2("hello!");
}
}
多线程的创建和启动
-
Java语言的JVM允许程序运行多个线程,它通过java.lang.Thread类来实现。
-
Thread类的特性
每个线程都是通过某个特定Thread对象的run()方法来完成操作的,经常把run()方法的主体称为线程体
通过该Thread对象的start()方法来调用这个线程
mt子线程的创建和启动过程
Thread类
-
构造方法
Thread():创建新的Thread对象
Thread(String threadname):创建线程并指定线程实例名
Thread(Runnable target):指定创建线程的目标对象,它实现了Runnable接口中的run方法
Thread(Runnable target, String name):创建新的Thread对象
创建线程的两种方式
1.继承Thread类
1)定义子类继承Thread类。
2)子类中重写Thread类中的run方法。
3)创建Thread子类对象,即创建了线程对象。
4)调用线程对象start方法:启动线程,调用run方法。
2. 实现Runnable接口
1)定义子类,实现Runnable接口。
2)子类中重写Runnable接口中的run方法。
3)通过Thread类含参构造器创建线程对象。
4)将Runnable接口的子类对象作为实际参数传递给
Thread类的构造方法中。
5)调用Thread类的start方法:开启线程,调用Runnable子类接口的run方法。
继承方式和实现方式的联系与区别
public class Thread extends Object implements Runnable
【区别】
继承Thread: 线程代码存放Thread子类run方法中。
实现Runnable:线程代码存在接口的子类的run方法
【实现方法的好处】
1)避免了单继承的局限性
2)多个线程可以共享同一个接口子类的对象,非常适合多个相同线程来处理同一份资源。
Thread类的有关方法(1)
- void start(): 启动线程
- run(): 线程在被调度时执行的操作
- String getName(): 返回线程的名称
- void setName(String name):设置该线程名称
- static currentThread(): 返回当前线程
Thread类的有关方法(2):线程的优先级
线程的优先级控制
- MAX_PRIORITY(10);
- MIN _PRIORITY (1);
- NORM_PRIORITY (5);
涉及的方法: - getPriority() :返回线程优先值
- setPriority(int newPriority) :改变线程的优先级
- 线程创建时继承父线程的优先级
线程的调度
调度策略
时间片:
抢占式:高优先级的线程抢占CPU
Java的调度方法
- 同优先级线程组成先进先出队列(先到先服务),使用时间片策略
- 对高优先级,使用优先调度的抢占式策略
Thread类的有关方法(3)
- static void yield():线程让步
---------暂停当前正在执行的线程,把执行机会让给优先级相同或更高的线程
---------若队列中没有同优先级的线程,忽略此方法
- join() :当某个程序执行流中调用其他线程的 join() 方法时,调用线程将被阻塞,直到 join() 方法加入的 join
线程执行完为止
---------低优先级的线程也可以获得执行
- static void sleep(long millis):(指定时间:毫秒)
---------令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
---------抛出InterruptedException异常
- stop(): 强制线程生命期结束
- boolean isAlive():返回boolean,判断线程是否还活着
为什么需要多线程?
背景:只使用单个线程完成多个任务(调用多个方法),肯定比用多个线程来完成用的时间更短,为何仍需多线程呢?
多线程程序的优点:
- 提高应用程序的响应。对图形化界面更有意义,可增强用户体验。
- 提高计算机系统CPU的利用率
- 改善程序结构。将既长又复杂的进程分为多个线程,独立运行,利于理解和修改
补充:线程的分类
Java中的线程分为两类:一种是守护线程,一种是用户线程。
- 它们在几乎每个方面都是相同的,唯一的区别是判断JVM何时离开。
- 守护线程是用来服务用户线程的,通过在start()方法前调用 thread.setDaemon(true) 可以把一个用户线程变成一个守护线程。
- Java垃圾回收就是一个典型的守护线程。
- 若JVM中都是守护线程,当前JVM将退出。
------皮之不复毛将焉存
三、线程的生命周期
JDK中用Thread.State枚举表示了线程的几种状态
- 要想实现多线程,必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程,在它的一个完整的生命周期中通常要经历如下的五种状态:
新建: 当一个Thread类或其子类的对象被声明并创建时,新生的线程对象处于新建状态
就绪:处于新建状态的线程被start()后,将进入线程队列等待CPU时间片,此时它已具备了运行的条件
运行:当就绪的线程被调度并获得处理器资源时,便进入运行状态, run()方法定义了线程的操作和功能
阻塞:在某种特殊情况下,被人为挂起或执行输入输出操作时,让出 CPU 并临时中止自己的执行,进入阻塞状态
死亡:线程完成了它的全部工作或线程被提前强制性地中止
四、线程的同步
-
问题的提出
多个线程执行的不确定性引起执行结果的不稳定 多个线程对账本的共享,会造成操作的不完整性,会破坏数据。
例题:模拟火车站售票程序,开启三个售票窗口
/*创建线程的第一种方式
* 开启三个窗口卖票
* */
class Ticket extends Thread{
static int ticket = 100;
public void run(){
while(true){
if(ticket>0){
System.out.println(Thread.currentThread().getName()+"售票,票号为:"+ ticket--);
}else
break;
}
}
}
public class TestTicket {
public static void main(String[] args){
Ticket t1 = new Ticket();
Ticket t2 = new Ticket();
Ticket t3 = new Ticket();
t1.setName("t1窗口");
t2.setName("t2窗口");
t3.setName("t3窗口");
t1.start();
t2.start();
t3.start();
}
}
1.多线程出现了安全问题
2.问题的原因:
当多条语句在操作同一线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行,导致共享数据的错误。
3.解决办法:
对多条操作共享数据的语句,只能让一个线程都执行完,在执行过程中,其他线程不可以参与执行。
Synchronized的使用方法
- Java对于多线程的安全问题提供了专业的解决方式: 同步代码块
1.synchronized (对象){
// 需要被同步的代码;
}
2.synchronized还可以放在方法声明中,表示整个方法为同步方法。
例如:
public synchronized void show (String name){
….
}
创建多线程的第一种方式:继承Thread类
/*
* 1.创建线程的第一种方式
*
* 2.Thread类里的常用方法
* 2.1getName();
* 2.2setName();
* 2.3start();开启线程并调用相应的run()执行
* 2.4run()
* 2.5yield():“贡献”出当前线程对CPU的获取
* 2.6join():在a线程中调用了b线程的join()方法,那么当b线程完全执行完成后,a线程才可以继续执行*/
//1.1声明类继承Thread类
class MyThread1 extends Thread{
//1.2重写run方法,这是创建的多线程的执行的主体
public void run(){
for(int i = 1;i<=100;i++){
System.out.println(Thread.currentThread().getName()+":"+i );
}
}
public MyThread1(){
}
public MyThread1(String name){
super(name);
}
}
public class TestThread1 {
public static void main(String[] args){
//1.3创建继承Thread类的子类的实例
MyThread1 m1 = new MyThread1("线程1");
MyThread1 m2 = new MyThread1();
m2.setName("线程2");//给线程命名的两种方式
//1.4调用对象的start()方法:1.启动线程 2调用相应线程对应类的run()方法
m1.start();
m2.start();
System.out.println("---"+ m1.isAlive());
for(int i = 1;i<=100;i++){
// if(i%10 ==0){
// Thread.yield();
// }
if(i/20 == 0){
try{
m1.join();
}catch(InterruptedException e){
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+":"+i );
}
System.out.println("---"+ m1.isAlive());
}
}
创建多线程的第二种方式:实现Runnable接口
package com.atguigu.java;
//开启三个窗口卖票
//创建多线程的第二种方式:实现Runnable接口
//1.创建实现Runnable接口的类
class Ticket1 implements Runnable{
int ticket = 100;
//2.重写Runnable接口的抽象方法
public void run(){
while(true){
if(ticket>0){
System.out.println(Thread.currentThread().getName()+"售票,票号为:"+ ticket--);
}else
break;
}
}
}
public class TestTicket1 {
public static void main(String[] args){
//3.创建一个实现接口的子类对象
Ticket1 t = new Ticket1();
//4.将创建的子类对象作为形参传递给Thread的构造器
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
t1.setName("t1窗口");
t2.setName("t2窗口");
t3.setName("t3窗口");
//5.调用线程的start()方法
t1.start();
t2.start();
t3.start();
}
}
多线程安全问题的解决
方式1:使用同步代码块
方式2:使用同步方法
package com.atguigu.java;
//开启三个窗口卖票
//可能出现线程安全问题
//1.出现安全问题的原因:当多个线程有共享数据时,由于一个线程对共享数据的操作尚未完成,其他线程就参与进来。
//2.如何解决线程的安全问题:要保证当一个线程操作共享数据时,其他线程必须在外面等侯,直到操作共享数据的线程操作完,
//其他线程才可以操作共享数据
//3.如何来操作:1)java如何实现的2)什么是共享数据?
//4.java中如何实现线程的安全:①通过synchronized同步代码块 ②使用synchronized同步方法
//创建多线程的第二种方式:实现Runnable接口
//1.创建实现Runnable接口的类
class Ticket2 implements Runnable{
int ticket = 100;
Object obj = new Object();//这个锁(同步监视器)要放在run()方法外面,这个是唯一的一个锁,如果放在run()方法里面,意思就是每个线程都有一个自己的锁,还是会有线程问题
//2.重写Runnable接口的抽象方法
public void run(){
while(true){
//synchronized(this){//this:当前对象,同步监视器(或锁)
show();//同步方法,调用show方法
//}
}
}
public synchronized void show(){//同步方法默认的锁是当前对象。
if(ticket>0){
try {
Thread.currentThread().sleep(100);//可能造成ticket = 0 和 ticket = -1,线程安全问题
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"售票,票号为:"+ ticket--);
}
}
}
public class TestTicket2 {
public static void main(String[] args){
//3.创建一个实现接口的子类对象
Ticket2 t = new Ticket2();
//4.将创建的子类对象作为形参传递给Thread的构造器
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
t1.setName("t1窗口");
t2.setName("t2窗口");
t3.setName("t3窗口");
//5.调用线程的start()方法
t1.start();
t2.start();
t3.start();
}
}
互斥锁
-
在Java语言中,引入了对象互斥锁的概念,来保证共享数据操作的完整性。
每个对象都对应于一个可称为“互斥锁”的标记,这个标记用来保证在任一时刻,只能有一个线程访问该对象。
关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时,表明该对象在任一时刻只能由一个线程访问。
同步的局限性:导致程序的执行效率要降低
同步方法(非静态的)的锁为this。
线程的死锁问题
死锁
不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁
解决方法
专门的算法、原则
尽量减少同步资源的定义