JSE-13(多线程)

本章内容

第一节 线程的概念与原理

第二节 线程的创建、运行和结束

第三节 线程的控制

第四节 线程同步

第五节 线程通信

第一节 线程的概念与原理

基本概念：程序 - 进程 - 线程

程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。

如：运行中的QQ，运行中的MP3播放器

程序是静态的，进程是动态的

线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。

若一个程序可同一时间执行多个线程，就是支持多线程的

进程与多线程

何时需要多线程

程序需要同时执行两个或多个任务。

程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。

需要一些后台运行的程序时。

使用多线程的优点

背景：只使用单个线程完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？

多线程程序的优点：

提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

提高计算机系统CPU的利用率

改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

第二节 线程的创建、运行和结束

线程的创建和启动

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对象

Thread类的有关方法(1)

void start(): 启动线程，并执行对象的run()方法

run(): 线程在被调度时执行的操作

String getName(): 返回线程的名称

void setName(String name):设置该线程名称

static currentThread(): 返回当前线程

创建线程的两种方式

继承Thread类

1. 定义子类继承Thread类。
2. 子类中重写Thread类中的run方法。
3. 创建Thread子类对象，即创建了线程对象。
4. 调用线程对象start方法：启动线程，调用run方法。

创建线程的两种方式

实现Runnable接口

1）定义子类，实现Runnable接口。

2）子类中重写Runnable接口中的run方法。

3）通过Thread类含参构造器创建线程对象。

4）将Runnable接口的子类对象作为实际参数传递给

Thread类的构造方法中。

5）调用Thread类的start方法：开启线程，调用

Runnable子类接口的run方法。

继承方式和实现方式的联系与区别

public class Thread extends Object implements Runnable

练 习

创建两个子线程，让其中一个输出1-100之间的偶数，另一个输出1-100之间的奇数。

在main方法中创建并启动一个线程，该线程随机产生100个0-100整数，打印后结束；

在main方法中创建并启动两个线程。第一个线程统计指定目录下的文件个数及所占总空间数并打印输出，另一个线程打印输出此目录中每个文件信息如文件名称和大小。

结束线程 — 使用通知方式

当线程完成执行并结束后，就无法再次运行了。

应该通过使用标志来指示run方法退出的方式来停止线程，即通知方式。

该方式可确保线程以安全的方式结束运行。

结束线程示例 — HelloRunner类

public class HelloRunner implements Runnable { private int i; private boolean stopFlag = false; public void run() { while (!stopFlag) { System.out.print((i++) + " "); if (i > 500) i = 0; ｝ } public void setStopFlag(boolean stopFlag) { this.stopFlag = stopFlag; } }

结束线程示例 — TestEndThread类

public class TestEndThread { public static void main(String[] args) { HelloRunner r = new HelloRunner(); Thread t = new Thread(r); t.start(); for (int i = 0; i < 100; i++) { System.out.print("--" + i); } r.setStopFlag(true); } }

练 习

在main方法中创建并启动两个线程。第一个线程循环随机打印100以内的整数，直到第二个线程从键盘读取了“Q”命令。

第三节 线程的控制

线程的调度

Thread类的有关方法(2)

static void yield()：线程让步

暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程

若队列中没有同优先级的线程，忽略此方法

join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止

低优先级的线程也可以获得执行

static void sleep(long millis)：(指定时间:毫秒)

令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。

抛出InterruptedException异常

boolean isAlive()：返回boolean，判断线程是否还活着

线程的优先级

线程的优先级控制

MAX_PRIORITY（10）;

MIN _PRIORITY （1）;

NORM_PRIORITY （5）;

涉及的方法：

getPriority() ：返回线程优先值

setPriority(int newPriority) ：改变线程的优先级

线程创建时继承父线程的优先级

补充：线程的分类

Java中的线程分为两类：一种是守护线程，一种是用户线程。

它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。

守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。

Java垃圾回收就是一个典型的守护线程。

若JVM中都是守护线程，当前JVM将退出。

线程的生命周期

JDK中用Thread.State枚举表示了线程的几种状态

要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态

就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件

运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能

阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态

死亡：线程完成了它的全部工作或线程被提前强制性地中止

练 习

编写程序，在main方法中创建一个线程。线程每隔一定时间（200ms以内的随机时间）产生一个0-100之间的随机整数，打印后将该整数放到集合中；

共产生100个整数，全部产生后，睡眠30秒，然后将集合内容打印输出；

在main线程中，唤醒上述睡眠的线程，使其尽快打印集合内容。

第四节 线程同步

线程的同步

问题的提出

多个线程执行的不确定性引起执行结果的不稳定

多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

例 题

模拟火车站售票程序，开启三个窗口售票。

class Ticket implements Runnable{ private int tick = 100; public void run(){ while(true){ if(tick>0){ System.out.println(Thread.currentThread().getName()+“售出车票，tick号为："+ tick--); } else break; } } } class TicketDemo{ public static void main(String[] args) { Ticket t = new Ticket(); Thread t1 = new Thread(t); Thread t2 = new Thread(t); Thread t3 = new Thread(t); t1.setName("t1窗口"); t2.setName("t2窗口"); t3.setName("t3窗口"); t1.start(); t2.start(); t3.start(); } }

private int tick = 100; public void run(){ while(true){ if(tick>0){ try{ Thread.sleep(10); }catch(InterruptedException e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+“售出车票，tick号为： "+tick--); } } }

Synchronized的使用方法

Java对于多线程的安全问题提供了专业的解决方式：

同步代码块

synchronized (对象）{

// 需要被同步的代码；

}

synchronized还可以放在方法声明中，表示整个方法

为同步方法。

例如：

public synchronized void show (String name){

….

}

分析同步原理

互斥锁

在Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。

每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。

关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。

同步的局限性：导致程序的执行效率要降低

同步方法（非静态的）的锁为this。

单例设计模式之懒汉式

class Singleton { private static Singleton instance = null; private Singleton(){} public static Singleton getInstance(){ if(instance==null){ synchronized(Singleton.class){ if(instance == null){ instance=new Singleton(); } } } return instance; } } public class TestSingleton{ public static void main(String[] args){ Singleton s1=Singleton.getInstance(); Singleton s2=Singleton.getInstance(); System.out.println(s1==s2); } }

练 习1

银行有一个账户。

有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。

问题：该程序是否有安全问题，如果有，如何解决？

【提示】

1，明确哪些代码是多线程运行代码，须写入run()方法

2，明确什么是共享数据。

3，明确多线程运行代码中哪些语句是操作共享数据的。

拓展问题：可否实现两个储户交替存钱的操作

小结：释放锁的操作

当前线程的同步方法、同步代码块执行结束

当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。

当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束

当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

小结：不会释放锁的操作

线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行

线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。

应尽量避免使用suspend()和resume()来控制线程

线程的死锁问题

死锁

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

解决方法

专门的算法、原则

尽量减少同步资源的定义

public class TestDeadLock { public static void main(String[] args) { final StringBuffer s1 = new StringBuffer(); final StringBuffer s2 = new StringBuffer(); new Thread() { public void run() { synchronized (s1) { s2.append("A"); synchronized (s2) { s2.append("B"); System.out.print(s1); System.out.print(s2); }}}}.start();

new Thread() { public void run() { synchronized (s2) { s2.append("C"); synchronized (s1) { s1.append("D"); System.out.print(s2); System.out.print(s1); }}}}.start(); }}

第五节 线程通信

线程通信

wait() 与 notify() 和 notifyAll()

wait()：令当前线程挂起并放弃CPU、同步资源，使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问

notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待

notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.

Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常

wait() 方法

在当前线程中调用方法： 对象名.wait()

使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify (或notifyAll) 为止。

调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

调用此方法后，当前线程将释放对象监控权 ，然后进入等待

在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。

notify()/notifyAll()

在当前线程中调用方法： 对象名.notify()

功能：唤醒等待该对象监控权的一个线程。

调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

例 题

使用两个线程打印 1-100. 线程1, 线程2 交替打印

class Communication implements Runnable{ int i = 1; public void run() { while (true) { synchronized (this) { notify(); if (i <= 100) { System.out.println(Thread.currentThread().getName() + ":" i++); } else break; try { wait();} catch (InterruptedException e) { }}}}}

经典例题：生产者/消费者问题

生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

这里可能出现两个问题：

生产者比消费者快时，消费者会漏掉一些数据没有取到。

消费者比生产者快时，消费者会取相同的数据。

public class TestProduct { public static void main(String[] args) { Clerk clerk = new Clerk(); Thread productorThread = new Thread(new Productor(clerk)); Thread consumerThread = new Thread(new Consumer(clerk)); productorThread.start(); consumerThread.start(); } }

class Clerk{ //售货员 private int product = 0; public synchronized void addProduct(){ if(product >= 20){ try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } }else{ product++; System.out.println("生产者生产了第"+product+"个产品"); notifyAll(); }}

public synchronized void getProduct(){ if(this.product <= 0){ try { wait(); } catch (InterruptedException e) { e.printStackTrace(); }}else{ System.out.println("消费者取走了第"+product+"个产品"); product--; notifyAll(); }}}

class Productor implements Runnable{ //生产者 Clerk clerk; public Productor(Clerk clerk){ this.clerk = clerk; } public void run(){ System.out.println("生产者开始生产产品"); while(true){ try { Thread.sleep((int)Math.random()*1000); } catch (InterruptedException e) { } clerk.addProduct(); } } }

class Consumer implements Runnable{ //消费者 Clerk clerk; public Consumer(Clerk clerk){ this.clerk = clerk; } public void run(){ System.out.println("消费者开始取走产品"); while(true){ try { Thread.sleep((int)Math.random()*1000); } catch (InterruptedException e) { } clerk.getProduct(); } } }

练 习 2

模拟银行取钱的问题

1.定义一个Account类

1）该Account类封装了账户编号（String）和余额（double）两个属性

2）设置相应属性的getter和setter方法

3）提供无参和有两个参数的构造器

4）系统根据账号判断与用户是否匹配，需提供hashCode()和equals()方法的重写

2.提供一个取钱的线程类

1）提供了Account类的account属性和double类的取款额的属性

2）提供带线程名的构造方法

3）run()方法中提供取钱的操作

3.在主类中创建线程进行测试。考虑线程安全问题。

public class Account { private String accountId; private double balance; public Account(){ } public Account(String accountId,double balance){ this.accountId = accountId; this.balance = balance;} public String getAccountId() { return accountId;} public void setAccountId(String accountId) { this.accountId = accountId;} public double getBalance() { return balance;} public void setBalance(double balance) { this.balance = balance;} public String toString() { return "Account [accountId=" + accountId + ", balance=" + balance + "]"; }

public int hashCode() { final int prime = 31; int result = 1; result = prime * result ((accountId == null) ? 0 : accountId.hashCode()); long temp; temp = Double.doubleToLongBits(balance); result = prime * result + (int) (temp ^ (temp >>> 32)); return result;} public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Account other = (Account) obj; if (accountId == null) { if (other.accountId != null) return false; } else if (!accountId.equals(other.accountId)) return false; if (Double.doubleToLongBits(balance) != Double .doubleToLongBits(other.balance)) return false; return true;}

public class WithDrawThread extends Thread{ Account account; //要取款的额度 double withDraw; public WithDrawThread(String name,Account account,double amt){ super(name); this.account = account; this.withDraw = amt;} public void run(){ synchronized (account) { if (account.getBalance() > withDraw) { System.out.println(Thread.currentThread().getName() ":取款成功，取现的金额为：" + withDraw); try {Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace();} account.setBalance(account.getBalance() - withDraw); } else { System.out.println("取现额度超过账户余额，取款失败");} System.out.println("现在账户的余额为：" + account.getBalance()); }}}

public class TestWithDrawThread { public static void main(String[] args) { Account account = new Account("1234567",10000); Thread t1 = new WithDrawThread("小明",account,8000); Thread t2 = new WithDrawThread("小明's wife",account,2800); t1.start(); t2.start(); } }