前面的博客主要说了 java 语言的相关内容,下面的博客说 javase 类库框架相关的类容。在 java 语言里面,多线程是用 Thread 类和 Runable 接口来实现的,我认为这个应该不属于基础的语言规则,但是 javase 还是把这两个类放在了 java.lang 包下面,是不是因为所有的编程语言都必须支持多线程这个基本的特性,或者因为java里面线程同步用的关键字 synchronized , 是 java 语言级的东西。其实多线程这个特性是操作系统提供的。和异常类似的是,多线程相关的内容,线程创建部分内容是 javase 框架的类库中 Thread 类和 Runable 接口实现的,而线程同步部分中,部分内容是synchronized 关键字实现的,部分内容是类库中的功能实现的。
多线程部分相关内容有
- 进程和线程的概念
- 线程的创建方法
- 多线程间的同步
- 多线程间的通信
- 停止线程
- 线程合并
- 守护线程
进程和线程的概念
进程和线程,都是并发程序设计里面产生的概念,并发并不是真正的并行,当然现在多核cpu可以算并行了,以前单核cpu的时候,并发程序由于切换特别快,看起来好像多个程序时同时运行。程序主要是指硬盘上保存的程序的文件,是静态的概念,进程主要是程序被加载到内存中,被cpu或者操作系统执行时的概念,是动态概念,一个进程就是指一个计算机任务。进程是任务的基本单位,线程是cpu的基本单位。
线程是程序中一个单一的顺序控制流程.在单个程序中同时运行多个线程完成不同的工作,称为多线程.要弄清楚线程,须结合进程加以理解:
进程是一个可执行的程序,由私有虚拟地址空间、代码、数据和其他操作系统资源(如进程创建的文件、管道、同步对象等)组成。一个应用程序可以有一个或多个进程,一个进程可以有一个或多个线程,其中一个是主线程。
线程是操作系统分时调度分配CPU时间的基本实体。一个线程可以执行程序的任意部分的代码,即使这部分代码被另一个线程并发地执行;一个进程的所有线程共享它的虚拟地址空间、全局变量和操作系统资源。之所以有线程这个概念,是因为以线程而不是进程为调度对象效率更高:由于创建新进程必须加载代码,而线程要执行的代码已经被映射到进程的地址空间,所以创建、执行线程的速度比进程更快。一个进程的所有线程共享进程的地址空间和全局变量,所以简化了线程之间的通讯。
进程是一个可执行的程序,由私有虚拟地址空间、代码、数据和其他操作系统资源(如进程创建的文件、管道、同步对象等)组成。一个应用程序可以有一个或多个进程,一个进程可以有一个或多个线程,其中一个是主线程。
线程是操作系统分时调度分配CPU时间的基本实体。一个线程可以执行程序的任意部分的代码,即使这部分代码被另一个线程并发地执行;一个进程的所有线程共享它的虚拟地址空间、全局变量和操作系统资源。之所以有线程这个概念,是因为以线程而不是进程为调度对象效率更高:由于创建新进程必须加载代码,而线程要执行的代码已经被映射到进程的地址空间,所以创建、执行线程的速度比进程更快。一个进程的所有线程共享进程的地址空间和全局变量,所以简化了线程之间的通讯。
有时候,线程也称作
轻量级进程。就象进程一样,线程在
程序中是独立的、并发的执行路径,每个线程有它自己的
堆栈、自己的
程序计数器和自己的
局部变量。但是,与分隔的进程相比,进程中的线程之间的隔离程度要小。它们共享
内存、
文件句柄和其它每个进程应有的状态。多个
线程之间,看似同时执行,但互相之间并不同步(所以需要
synchronized 来实现模拟同步的协调,
synchronized 主要使用互斥锁实现)。一个进程中的多个线程共享相同的内存地址空间,这就意味着它们可以访问相同的
变量和
对象,而且它们从同一堆中分配对象。尽管这让线程之间共享信息变得更容易,但您必须小心,确保它们不会妨碍同一进程里的其它线程。
进程和线程在内存中的结构如下图所示
总结起来,就是多线程之间共享堆,独立栈。
jvm 中的线程和这个稍有不同:
线程的创建方法
- 构建 Thread 类子类的方法
- 实现 Runable 接口的方法
构建 Thread 类子类的方法
在面向对象程序里面,一个应用程序是一个对象,一个线程也是一个对象,只是应用程序对象和线程对象是组合的关系。应用程序类依赖于线程类。他们在构造关系上,应用程序属于上层类,线程属于下层类,线程是应用程序的组成元素,但是它们不是继承上的关系,而是组合的关系。所以上下层关系,在面向对象里面有两种,一种是继承这种概念上抽象层次的上下层关系,一种是组合这种,拆分层次上的上下层关系。线程既然由 Thread 类来描述,那么 Thread 类主要对外提供了线程操作相关的接口。
- start() 启动线程
- run() 线程启动后执行的函数
- interrupt() 中断线程
- join() 合并线程
- sleep(long millis) 让当前线程休眠
- setDaemon(boolean on) 设置线程为守护线程
- setPriority(int newPriority) 设置线程优先级
- setName(String name) 设置线程名
其他获取线程相关信息的接口,还有几个线程相关的操作在 Object 类中描述的
创建线程实例
/**
需求:演示通过构造 Thread 子类,创建线程
思路:创建一个线程,打印和main线程不同东西
步骤:
1.定义类继承Thread。
2.复写Thread类中的run方法。
3.调用线程的start方法,该方法两个作用,启动线程,调用run方法
*/
class PrintedThread extends Thread
{
public void run()
{
for(int count=0; count < 100; count++)
{
System.out.println("child thread run..." + count);
}
}
}
class ThreadCreated
{
public static void main(String[] args)
{
PrintedThread printedThread = new PrintedThread();
printedThread.start();
for(int count=0; count < 100; count++)
{
System.out.println("main thread run..." + count);
}
}
}
这种覆盖 run 方法的模式,其实就是
《JavaSE 拾遗(5)——JavaSE 面向对象程序设计语言基础(5)》中的模板方法模式,有木有!
Thread 类用于描述线程,该类就定义了一个功能 run 用于存储线程要运行的代码。
获取线程名称和获取当前线程对象
Thread 类中的成员函数
String getName() 可以获取线程对象的标志名,线程对象默认标志名是 Thread-编号,编号从0开始。
setName() 可以设置线程对象的标志名
static
Thread
currentThread() 返回当前正在执行的线程对象的引用
实现 Runable 接口来创建线程
/**
需求:演示实现 Runnable 接口的方法来创建进程
思路:
步骤:
1.定义类实现 Runnable 接口
2.覆盖 Runnable 接口中的 run 方法
3.通过 Thread 类建立线程对象
4.将 Runnable 接口的子类对象作为参数传递给 Thread 类对象的构造函数
5.调用 Thread 类的 start 方法开启线程
总结: Runnable 接口是把 Thread 中未知功能封装起来了,让别的类来实现
Runnalbe 接口之后,再把对象的应用传给 Thread 类对象,那么就实
现了 Thread 对象启动新线程后去运行,run 中的方法。Runnable 接
口对 Thread 类的功能进行了扩展。
*/
class HelloJava implements Runnable
{
void run()
{
while(true)
{
System.out.println("Hello Java!");
}
}
}
class MultiThread
{
public static void main(String[] args)
{
Runnable helloJava = new helloJava();
Thread threadPrint = new thread(helloJava);
while(true)
{
System.out.println("Hello World!");
}
}
}
多线程同步
- 同步代码块方法
- 同步函数方法
线程有7种状态
-
1、线程的实现有两种方式,一是继承Thread类,二是实现Runnable接口,但不管怎样,当我们new了这个对象后,线程就进入了初始状态;
2、当该对象调用了start()方法,就进入可运行状态;
3、进入可运行状态后,当该对象被操作系统选中,获得CPU时间片就会进入运行状态;
4、进入运行状态后情况就比较复杂了
4.1、run()方法或main()方法结束后,线程就进入终止状态;
4.2、当线程调用了自身的sleep()方法或其他线程的join()方法,就会进入阻塞状态(该状态既停止当前线程,但并不释放所占有的资源)。当sleep()结束或join()结束后,该线程进入可运行状态,继续等待OS分配时间片;
4.3、线程调用了yield()方法,意思是放弃当前获得的CPU时间片,回到可运行状态,这时与其他进程处于同等竞争状态,OS有可能会接着又让这个进程进入运行状态;
4.4、当线程刚进入可运行状态(注意,还没运行),发现将要调用的资源被synchroniza(同步),获取不到锁标记,将会立即进入锁池状态,等待获取锁标记(这时的锁池里也许已经有了其他线程在等待获取锁标记,这时它们处于池状态,既随机得到锁),一旦线程获得锁标记后,就转入可运行状态,等待OS分配CPU时间片;
4.5、当线程调用wait()方法后会进入等待队列(进入这个状态会释放所占有的所有资源,与阻塞状态不同),进入这个状态后,是不能自动唤醒的,必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒(由于notify()只是唤醒一个线程,但我们由不能确定具体唤醒的是哪一个线程,也许我们需要唤醒的线程不能够被唤醒,因此在实际使用时,一般都用notifyAll()方法,唤醒有所线程),线程被唤醒后会进入锁池,等待获取锁标记。
同步代码块方法
/**
需求:演示多线程同步
思路:用线程表示售票员,多个售票员操作共同卖100张票
步骤:
问题原因:
当多条语句在操作多个线程的共享数据的时候,一个线程对这多条语句只执行了一小部分
还没有执行完对共享数据所有操作,就切换到另一个共享数据的线程,导致对共享数据的
操作形成错误。
解决方法:
对多条语句操作共享数据的线程,只能让一个线程都执行完这些语句,才能让另外的一个
线程执行这些共享数据操作的语句。则就是线程同步。
java 提供了同步代码块和同步函数两种方法实现同步。
synchronized 机制实际是互斥锁机制,Ojbect 对象都有锁数据成员变量,用来描述锁的
状态,java 还会把没有得到锁的线程置为锁池状态,锁池并不真正存在,是一个逻辑上的集
合,进入锁池的线程在置为可以运行状态之后再去拿钥匙(判断锁的状态),如果拿到钥匙就运行,
如果没有拿到就再次回到锁池状态。sychronized 块运行完之后无论是否运行都要还钥匙(开锁)
由于线程转到运行态是随机的,所以拿到钥匙的线程也是随机的。
同步的前提:
1.必须是2个或者2个以上线程,用使用多条语句操作多线程共享数据。
2.必须使用同一个锁。
*/
class Ticket implements Runnable
{
private int ticketCount = 100;
public void run()
{
while(true)
{
//synchronized(this)
synchronized(Ticket.class)
{
if(ticketCount > 0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName() + "...sale:" + ticketCount--);
}
else
{
break;
}
}
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread ticketSeller01 = new Thread(t);
Thread ticketSeller02 = new Thread(t);
Thread ticketSeller03 = new Thread(t);
Thread ticketSeller04 = new Thread(t);
Thread ticketSeller05 = new Thread(t);
ticketSeller01.start();
ticketSeller02.start();
ticketSeller03.start();
ticketSeller04.start();
ticketSeller05.start();
System.out.println("over!");
}
}
同步函数方法
/**
需求:演示多线程同步函数方法
思路:银行有一个金库,有两个储户分别存300元,每次存100,存3次
步骤:
如何找出多线程同步问题:
1.明确哪些代码是多线程代码
2.明确哪些共享数据
3.明确多线程共享代码哪些代码是操作共享数据的
总结:
1.同步函数使用的锁是 this 对象
2.静态同步函数使用的锁是函数所属类的 *.class 文件加载后形成的 Class 对象
静态成员进内存时,内存中没有本类对象,但是一定有该类对应的字节码文件对象,
该对象名是 类名.class,对象类型是 Class。
*/
class Bank
{
private int totalDeposits = 0;
//因为整个函数中的代码都具有同步性,所以直接用同步函数
public synchronized void add(int amount)
{
totalDeposits += amount;
try{Thread.sleep(10);}catch(Exception e){}
System.out.println("totalDeposits = " + totalDeposits);
}
}
class Depositor implements Runnable
{
private Bank bank;
public Depositor(Bank bank)
{
this.bank = bank;
}
public void run()
{
for(int count = 0; count < 3; count++)
{
bank.add(100);
}
}
}
class BankDemo
{
public static void main(String[] args)
{
Bank icbc = new Bank();
Thread sheldon = new Thread(new Depositor(icbc));
Thread spock = new Thread(new Depositor(icbc));
sheldon.start();
spock.start();
System.out.println("game over!");
}
}
多线程死锁
死锁经常发生在嵌套 synchronized ,并且锁对象不同的时候。
class Test1 implements Runnable
{
private boolean flag;
Test1(boolean flag)
{
this.flag = flag;
}
public void run()
{
if(flag)
{
while(true)
{
synchronized(MyLock.locka)
{
System.out.println("if locka");
synchronized(MyLock.lockb)
{
System.out.println("if lockb");
}
}
}
}
else
{
while(true)
{
synchronized(MyLock.lockb)
{
System.out.println("else lockb");
synchronized(MyLock.locka)
{
System.out.println("elcs locka");
}
}
}
}
}
}
class MyLock
{
static Object locka = new Object();
static Object lockb = new Object();
}
class DeadLockTest
{
public static void main(String[] args)
{
new Thread(new Test1(true)).start();
new Thread(new Test1(false)).start();
}
}
线程之间通信
线程间通信,是指线程之间交换数据。通常一个线程往共享数据区写数据,另一个线程往共享数据区读数据,就形成线程间通信,他们之间除了有前面说得(互斥那种)同步关系,还有固定的执行顺序,必须是写的线程完成后,才能执行读的线程。这种同步关系,java 提供了等待唤醒机制来实现。
等待唤醒方法1,Object 提供的 wait 和 notify 方法,因为 wait notify 是让当前线程主动放弃拿到的锁,所以这两个方法和锁密切相关,是要操作锁状态的方法,因为 java 里面,每个对象都可以有锁这个成员,所以锁在 Objec 中定义,那么 wait notify 也因此在 Object 中被定义。
生产者-消费者实例
/**
需求:使用线程间通信演示多个生产者-消费者模型
思路:
步骤:
*/
class ProducerConsumerDemo
{
public static void main(String[] args)
{
Resource resource = new Resource();
Thread producer01 = new Thread(new Producer(resource));
Thread producer02 = new Thread(new Producer(resource));
Thread consumer01 = new Thread(new Consumer(resource));
Thread consumer02 = new Thread(new Consumer(resource));
producer01.start();
producer02.start();
consumer01.start();
consumer02.start();
}
}
class Resource
{
private String name;
private int count = 1;
private boolean flag = false;
public synchronized void set(String name)
{
while(flag)
{
try{this.wait();}catch(Exception e){}
}
this.name = name+"---"+count++;
System.out.println(Thread.currentThread().getName() + "...生产者..." + this.name);
flag = true;
this.notifyAll();
}
public synchronized void out()
{
while(!flag)
{
try{this.wait();}catch(Exception e){}
}
System.out.println(Thread.currentThread().getName() + "...消费者..." + this.name);
flag = false;
this.notifyAll();
}
}
class Producer implements Runnable
{
private Resource resource;
public Producer(Resource resource)
{
this.resource = resource;
}
public void run()
{
while(true)
{
resource.set("商品");
}
}
}
class Consumer implements Runnable
{
private Resource resource;
public Consumer(Resource resource)
{
this.resource = resource;
}
public void run()
{
while(true)
{
resource.out();
}
}
}
wait()、notify()和notifyAll()
当使用 object.wait 的时候,会使当前线程释放 object 锁,并使当前线程阻塞,放入 wait 线程池队列中。notify唤醒的都是线程池中的线程,通常是线程池中的第一个线程。notifyAll唤醒线程池中的所有阻塞线程,把这些线程从等待状态置为 锁池状态。
这三个方法都使用在同步中,因为要对持有监视器(锁)的线程操作。所以要使用在同步中,因为只有同步的时候才具有锁。
为什么这些操作线程的方法要定义在Object类中呢?
因为这些方法在操作同步中线程时,都必须要标示它们所操作线程持有的锁。只有同一个锁上的被等待线程可以被同一个锁上的notify唤醒,不可以对不同锁中的线程进行唤醒。也就是说,等待和唤醒是对锁进行操作(实际上时改变锁对象的对象头中的锁状态位)。而锁可以是任意对象,而能被任意对象调用的方法定义在Object类中,所以把这三个方法定义在 Object 类中。
线程同步中的 Lock 和 Condition 接口
/**
需求:使用 Lock 和 Condition 接口实现,生产者-消费者模型
思路:
1.生产者-消费者,是同时进行各自的操作,所以有多少个生产者和消费者
就需要多少个线程。
2.生产者、消费者都和产品有关系。
3.生产者生产好产品后存在仓库,消费者从仓库取产品来消费
4.生产者只能在仓库没有放满的时候才生产
5.消费者只能在仓库还有产品的时候才消费
6.仓库现在暂时定为只能放1个产品,后面会扩建仓库,让仓库放更多产品
7.产品进出仓库都要把产品序列号记下,这里是直接打印到屏幕上
所以有 生产者 消费者 产品 仓库 线程 这些对象来完成整个系统
步骤:
步骤如代码所示,先整体后局部,先抽象后具体,依赖接口(依赖倒转)
*/
package cn.itcast.multithread;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class ProducerConsumerDemo {
public static void main(String[] args) {
Storage storageBox = new StorageBox();
Thread producer01 = new Thread(new Producer(storageBox));
Thread producer02 = new Thread(new Producer(storageBox));
Thread consumer01 = new Thread(new Consumer(storageBox));
Thread consumer02 = new Thread(new Consumer(storageBox));
producer01.start();
producer02.start();
consumer01.start();
consumer02.start();
}
}
interface Storage {
void saveProduce(Produce produce) throws InterruptedException;
Produce getProduce() throws InterruptedException;
}
class StorageBox implements Storage {
private Produce produce = null;
private boolean isFull = false;
private final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
public void saveProduce(Produce produce) throws InterruptedException {
lock.lock();
try {
if (isFull) {
notFull.await();
} else {
this.produce = produce;
System.out.println("存入产品" + produce.getNumber());
isFull = true;
notEmpty.signal();
}
} finally {
lock.unlock();
}
}
public Produce getProduce() throws InterruptedException {
Produce produce = null;
lock.lock();
try {
if (!isFull) {
notEmpty.await();
} else {
isFull = false;
produce = this.produce;
System.out.println(Thread.currentThread().getName() + "取出产品"
+ produce.getNumber());
notFull.signal();
}
} finally {
lock.unlock();
}
return produce;
}
}
class Producer implements Runnable {
private Storage storage;
private int number = 0;
Producer(Storage storage) {
this.storage = storage;
}
public void run() {
while (true) {
try {
this.number++;
storage.saveProduce(make(Thread.currentThread().getName() + "#"
+ this.number));
} catch (InterruptedException e) {
}
}
}
private Produce make(String produceNumber) throws InterruptedException {
return new Produce(produceNumber);
}
}
class Consumer implements Runnable {
Storage storage;
Consumer(Storage storage) {
this.storage = storage;
}
public void run() {
while (true) {
try {
useProduce();
} catch (InterruptedException e) {
}
}
}
private void useProduce() throws InterruptedException {
storage.getProduce();
}
}
class Produce {
private String produceNumber;
Produce(String produceNumber) {
this.produceNumber = produceNumber;
}
public String getNumber() {
return produceNumber;
}
}
JDK1.5中提供了多线程的升级解决方案:将同步synchronized替换成Lock接口操作;将Objec(监视器对象)的wait,notify,notifyAll,替换成Condition接口的相应操作,Condition对象可以通过Lock锁进行获取。这是一种显式的锁机制和显式的锁对象上的等待唤醒操作机制,它把等待唤醒动作封装成了Condition类对象,让一个锁可以对应多个Condition对象(监视器对象),即一个锁可以对应多组wait-notify。
停止线程
当线程处于 wait 或者 sleep join 等阻塞状态时,需要强行停止当前阻塞状态, 可以使用 Thread 对象的 interrupt 方法。
实例
/**
需求:使用 interrupt 方法让线程退出阻塞状态
思路:
步骤:
总结:
如何停止线程,因为 stop 方法由于安全原因已经过时,现在只有一个方法停止线程,那就是run方法运行结束。开启多线程运行,运行代码通常是
循环结构,所以要想run方法结束,只要控制住循环结束就可以,也就是可以结束线程。
特殊情况下,当线程处于阻塞状态,就不会读取到循环结束标记,那么线程就可能永远不能结束。线程资源就可能永远不释放,这时需要 Thread
对象提供的 interrupt 方法来中断线程的阻塞状态。interrupt 中断,是中断线程的现在的状态,使线程主动退出阻塞状态。
*/
class InterruptDemo
{
public static void main(String[] args)
{
Wait wait = new Wait();
Thread thread = new Thread(wait);
thread.start();
try
{
Thread.sleep(100);
}
catch (Exception e)
{
}
wait.setFlag(false);
thread.interrupt();
System.out.println("game over!");
}
}
class Wait implements Runnable
{
private boolean flag = true;
public synchronized void run()
{
while(flag)
{
try
{
wait();
}
catch (InterruptedException e)
{
System.out.println("InterruptedException");
}
}
}
public void setFlag(boolean flag)
{
this.flag = flag;
}
}
守护线程
守护线程就是后台线程,后台线程存在的作用就是为前台线程服务的,如果非守护线程都结束,java虚拟机就退出运行,后台线程自动结束。就像雅典娜和圣斗士的关系,圣斗士存在的意义就是守护雅典娜,如果雅典娜不存在了,圣斗士也就没有存在的意义了。Thread 为对象提供 setDaemon 方法来设置线程为守护线程,这个方法只能在启动线程前调用。
合并线程
如果一个父线程在某个位置需要和另一个子线程合并在一起,也就是一个父线程需要在某个位置等待另一个子线程结束后再运行。Thread 提供了 join 方法,在父线程语句中,通过子线程对象,调用 join 方法,就实现了在父线程该语句等待子线程合并。
/**
需求:线程合并
思路:
步骤:
*/
class ThreadJoin
{
public static void main(String[] args) throws InterruptedException
{
Thread childThread = new Thread(new ChildThread());
childThread.start();
childThread.join();
System.out.println("game over!");
}
}
class ChildThread implements Runnable
{
public void run()
{
try
{
Thread.sleep(100);
}
catch (InterruptedException e)
{
}
System.out.println("child thread joined");
}
}
多线程程序设计图示: