黑马程序员------毕老师视频笔记第十二天------多线程（3）

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

（回顾）

多线程导致安全问题的原因：

l 多个线程访问出现延迟

l 线程随机性

ps：线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的

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

格式

synchronized(对象){需要同步的代码;}

同步可以解决安全问题的根本原因就在那个对象上，该对象如同锁的功能

同步的前提：

l 同步需要两个或两个以上的线程

l 多个线程使用同一把锁

为满足这两个条件，不能称其为同步

同步的弊端：

当线程相当多时，每个线程都会去判断同步上的锁，这是很耗资源的，无形中会降低程序的运行效率

同步函数:

格式：在函数上加上synchronized 修饰符即可

一般函数用的锁是this

静态同步函数用的锁是所在类的Class对象，即字节码文件对象

线程状态：

New新建状态

Runnable可运行（就绪）状态

Running运行（正在运行）状态

Block阻塞（挂起）状态

Dead死亡状态

七.线程间通信

多个线程在操作同一个资源，但是操作的动作不同。

线程间通信---等待唤醒机制

public final void wait()throwsInterruptedException

public final void notify()

public final void notifyAll()

这三个函数都是用在同步中，因为要持有监视器（锁）的线程操作

思考：wait(),notify(),notifyAll()用来操作线程的方法为什么定义在了Object类中？

因为这些方法在操作同步中，线程同步都需要标识他们所操作线程持有的锁，只有同一个锁上被等待的线程，可以被同一个锁的notify唤醒，不可以对不同所中的线程进行等待唤醒。也就是说，等待和唤醒必须是同一个锁，所以要使用在同步中，因为只有同步才具有锁。

一言以蔽之，调用这些函数的对象是锁，锁可以使任意对象，所以这些方法一定要定义在Object类中。

wait和sleep的区别：

1.wait定义在Object类中，被锁调用，sleep定义在Thread类中，被线程调用

2.wait之后持锁线程进入Block状态，放锁，sleep之后线程进入Block状态，不放锁

3.wait之后需要notify或notifyAll唤醒，sleep之后时间到了会自动醒来进入Runnable状态

wait和sleep都声明抛出了中断异常

jdk1.5版本是Java一个里程碑式的改革，对于线程通信来说，将隐式的锁机制改成了显示的锁机制。

解决线程安全问题使用的同步形式，实际上就是锁机制。

而线程同步过程中，获取锁或者是释放锁，只有锁是最清楚的，所以将锁封装成了一个对象，就是Lock对象。

在jdk1.5以后的版本中，将Lock定义成一个接口，位于java.util.concurrent.locks包中。

public interfaceLock

而且，又定义了一些类直接实现这个接口

public classReetrantLock extends Object implements Lock,Serializable

public staticclass ReentrantReadWriteLock.ReadLock extends Object implementsLock,Serializable

public staticclass ReentrantReadWriteLock.WriteLock extends Object implementsLock,Serializable

这三个类实现了Lock接口

Lock接口中用void lock()获取锁，用void unlock()释放锁

在线程通信的等待唤醒机制中，原来用来等待和唤醒的功能wait、notify、notifyAll方法位于Object类中，现在变成await()、signal、signalAll封装在Condition对象中。

Condition也是一个接口，要创建某个锁对应的condition对象，应该这么定义

Lock lock = newRerntrantLock();

Condition c =lock.newCondition();

c.await();

c.signal();

八.多线程常用API

Thread中常用的API有

static Thread currentThread();返回当前正在运行的线程

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

boolean isDaemon() 测试该线程是否为守护线程

void setDaemon() 将该线程设置为守护线程，需在启动线程前调用

void join() 在当前运行的线程中临时加入一个线程

void setPriority() 设置当前线程的优先级

int getPriority() 获得线程的优先级

static void sleep(long millis) 使该线程放弃执行权，进入休眠，时间到自动转醒

void interrupt() 中断线程

示例：

//主线程
class ThreadDemo
{
public static void main(String[] args)
{
//定义临界资源
Resource res = new Resource();
//定义两个线程负责存入和取出，并启动

/*
Deposit d = new Deposit(res);
Remove r = new Remove(res);
Thread deposit = new Thread(d);
Thread remove = new Thread(r);
deposit.start();
remove.start();
*/

new Thread(new Deposit(res)).start();
new Thread(new Remove(res)).start();

System.out.println("main over");
}
}

//定义临界资源
class Resource
{
int goodsItem = 0;
boolean isEmpty = true;

public void deposit()
{
while(goodsItem<100)
{
synchronized(this)
{
while (!isEmpty)
try{wait();}catch (InterruptedException e){}
System.out.print("in:"+goodsItem+" ");
goodsItem++;
isEmpty = false;
notify();
}
}
}
public void remove()
{
while(goodsItem<100)
{
synchronized(this)
{
while (isEmpty)
try{wait();}catch (InterruptedException e){}
System.out.println("out:..........."+goodsItem);
isEmpty = true;
notify();
}
}
}
}
//定义存入线程运行代码
class Deposit implements Runnable
{
private Resource res = null;
Deposit(Resource res)
{
this.res = res;
}
public void run()
{
res.deposit();
}
}
//定义取出线程运行代码
class Remove implements Runnable
{
private Resource res = null;
Remove(Resource res)
{
this.res = res;
}
public void run()
{
res.remove();
}
}

用Lock修改示例如下：

import java.util.concurrent.locks.*;
//主线程
class ThreadDemo
{
public static void main(String[] args)
{
//定义临界资源
Resource res = new Resource();
//定义两个线程负责存入和取出，并启动

/*
Deposit d = new Deposit(res);
Remove r = new Remove(res);
Thread deposit = new Thread(d);
Thread remove = new Thread(r);
deposit.start();
remove.start();
*/

new Thread(new Deposit(res)).start();
new Thread(new Remove(res)).start();

System.out.println("main over");
}
}

//定义临界资源
class Resource
{
int goodsItem = 0;
boolean isEmpty = true;

Lock lock = new ReentrantLock();
Condition con = lock.newCondition();

public void deposit()
{
while(goodsItem<100)
{
lock.lock();
try
{
while (!isEmpty)
con.await();
System.out.print("in:"+goodsItem+" ");
goodsItem++;
isEmpty = false;
con.signal();
}catch(Exception e){}
finally
{lock.unlock();}
}
}
public void remove()
{
while(goodsItem<100)
{
lock.lock();
try{
while (isEmpty)
con.await();
System.out.println("out:..........."+goodsItem);
isEmpty = true;
con.signal();
}catch(Exception e){}
finally
{lock.unlock();}
}
}
}
//定义存入线程运行代码
class Deposit implements Runnable
{
private Resource res = null;
Deposit(Resource res)
{
this.res = res;
}
public void run()
{
res.deposit();
}
}
//定义取出线程运行代码
class Remove implements Runnable
{
private Resource res = null;
Remove(Resource res)
{
this.res = res;
}
public void run()
{
res.remove();
}
}

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------