java中线程安全，线程死锁，线程通信快速入门
一：多线程安全问题
1 引入
复制代码
/*
* 多线程并发访问同一个数据资源
* 3个线程,对一个票资源,出售
*/
public class ThreadDemo {
public static void main(String[] args) {
//创建Runnable接口实现类对象
Tickets t = new Tickets();
//创建3个Thread类对象,传递Runnable接口实现类
Thread t0 = new Thread(t);
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t0.start();
t1.start();
t2.start();
}
}
/*
* 通过线程休眠,出现安全问题
*/
public class Tickets implements Runnable{
//定义出售的票源
private int ticket = 100;
private Object obj = new Object();
public void run(){
while(true){
//对票数判断,大于0,可以出售,变量--操作
if( ticket > 0){
try{
Thread.sleep(50); //加了休眠让其他线程有执行机会
}catch(Exception ex){}
System.out.println(Thread.currentThread().getName()+" 出售第 "+ticket--);
}
}
}
}复制代码
运行结果出现了这么一种情况：
可见票数为0和-1时都进行了售卖，由此可见多线程操作共享数据存在安全隐患
具体的讲:该处有三个线程t0,t1,t2同时对tickets进行操作，程序一运行，3个线程抢占CPU资源，运行执行过if(tickets>0)接着执行休眠操作，在这短短50ms的够CPU干很多事了，继续卖票。到最后休眠时间结束，线程无需在进行判断tickets是否大于0，便接着往下执行，就导致了安全问题
###2：解决办法
2.1java中提供了同步机制，能够解决线程的安全性问题。
复制代码
//同步代码块， 同步代码块的锁对象可以是任意的对象
synchronized (锁对象){
可能产生线程安全问题的代码
}
//同步方法， 同步方法中的锁对象是 this
public synchronized void method()
可能产生线程安全问题的代码
}
//静态同步方法，静态同步方法中的锁对象是 类名.class
public synchronized void method()
可能产生线程安全问题的代码
}
复制代码
2.2同步方法(推荐)或同步代码块解决该售票例子的线程安全问题
复制代码
public class Tickets implements Runnable {
// 共一百票
int tickets = 20;
Object obj = new Object();
@Override
public void run() {
// 模拟卖票
while (true) {
method();
}
}
public synchronized void method() {
if (tickets > 0) {
// 线程休眠模拟安全问题
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在卖票：" + tickets--);
}
}
}
复制代码
2.3同步代码块的原理
同步操作给对象上了一把对象锁（对象监视器），没有锁的线程不能够继续往下执行，只能等。
线程遇到同步代码块后，线程判断是否有同步锁，有则获取锁，进入同步中去执行，执行完毕释放锁。没有则不能够进行同步代码块中
由于加了同步后，线程进同步判断锁，获取锁，执行完毕释放锁，导致程序的运行速度下降。
举个上厕所的例子：假设有一片区域只有一个厕所且只有一个坑位(共享数据)，有三人A,B,C(三线程)需要上厕所，A拿着钥匙先进去上小厕，需要开门，这个门就相当于对象锁，你进来就得先开门并关上，小厕上了一分钟(Thread.sleep)，上完出来给钥匙给B(释放锁),B在拿着钥匙去开门上大厕，时间十分钟。。这时候C就只能在门外干急着了等B上完了
3：Lock锁对synchronized的改进
使用同步方法有个缺点：当在sleep休眠时若发生了异常，则该线程是出不了同步的，锁对象释放不了。
因此,SUN公司在jdk5后提供了个Lock接口，Lock接口中的常用方法
void lock()
void unlock()
复制代码
public class Tickets implements Runnable {
// 共一百票
int tickets = 20;
private Lock lock = new ReentrantLock();
@Override
public void run() {
// 模拟卖票
while (true) {
//调用lock方法加锁
lock.lock();
if (tickets > 0) {
// 线程休眠模拟安全问题
try {
Thread.sleep(50);
System.out.println(Thread.currentThread().getName()+" 出售第"+tickets--);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
}
}
复制代码
二：线程的死锁
同步锁使用的弊端：当线程任务中出现了多个同步(多个锁)时，如果同步中嵌套了其他的同步。这时容易引发一种现象：程序出现无限等待，这种现象我们称为死锁。这种情况能避免就避免掉
synchronzied(A锁){
synchronized(B锁){
}
}
死锁的一个形象比喻：两个人打架互相揪着对方头发不放，A说你先放，B说你先放，两人都不肯先放，就造成了死锁.
下面为产生死锁的一个例子
复制代码
public class lockA {
//保证对象的唯一性
private lockA(){
}
public final static lockA locka = new lockA();}
public class LockB {
//保证对象的唯一性
private LockB() {
}
public static final LockB lockb = new LockB();}
public class DeadLock implements Runnable {
private int i = 0;
@Override
public void run() {
while (true) {
if (i % 2 == 0) {
// 先进入A同步，在进入B同步
synchronized (lockA.locka) {
System.out.println("if---locka");
synchronized(LockB.lockb){
System.out.println("if---lockb");
}
}
} else {
//先进入B同步在进入A同步
synchronized (LockB.lockb) {
System.out.println("else---lockb");
synchronized(lockA.locka){
System.out.println("else---locka");
}
}
}
i++;
}
}
}
public class DeadLockDemo {
public static void main(String[] args) {
DeadLock deadLock = new DeadLock();
Thread t0 = new Thread(deadLock);
Thread t1 = new Thread(deadLock);
t0.start();t1.start();
}}
复制代码
三：线程通信
线程之间的通信：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制
打个比喻：就好像平时收快递一样，快递先由卖家包装，联系收件人员收发货，快递一路经过各个地点中转在到达你的手里。把这一系列过程看作一个个线程，所有线程共同合作处理你这个包裹，从而达到有效利用资源。
等待唤醒机制所涉及到的方法：
wait（） :等待，将正在执行的线程释放其执行资格 和 执行权，并存储到线程池中。
notify（）：唤醒，唤醒线程池中被wait（）的线程，一次唤醒一个，而且是任意的。
notifyAll（）： 唤醒全部：可以将线程池中的所有wait() 线程都唤醒。
其实，所谓唤醒的意思就是让 线程池中的线程具备执行资格。必须注意的是，这些方法都是在 同步中才有效。同时这些方法在使用时必须标明所属锁，这样才可以明确出这些方法操作的到底是哪个锁上的线程。
仔细查看JavaAPI之后，发现这些方法 并不定义在 Thread中，也没定义在Runnable接口中，却被定义在了Object类中，为什么这些操作线程的方法定义在Object类中？
因为这些方法在使用时，必须要标明所属的锁，而锁又可以是任意对象。能被任意对象调用的方法一定定义在Object类中。
Java实现代码如下：
复制代码
A 线程等待与唤醒案例的实现
/*
* 定义资源类,有2个成员变量
* name,sex
* 同时有2个线程,对资源中的变量操作
* 1个对name,age赋值
* 2个对name,age做变量的输出打印
*/
public class Resource {
public String name;
public String sex;
public boolean flag = false;
}
/*
* 输入的线程,对资源对象Resource中成员变量赋值
* 一次赋值 张三,男
* 下一次赋值 lisi,nv
*/
public class Input implements Runnable {
private Resource r ;
public Input(Resource r){
this.r = r;
}
public void run() {
int i = 0 ;
while(true){
synchronized(r){
//标记是true,等待
if(r.flag){
try{r.wait();}catch(Exception ex){}
}
if(i%2==0){
r.name = "张三";
r.sex = "男";
}else{
r.name = "lisi";
r.sex = "nv";
}
//将对方线程唤醒,标记改为true
r.flag = true;
r.notify();
}
i++;
}
}
}
/*
* 输出线程,对资源对象Resource中成员变量,输出值
*/
public class Output implements Runnable {
private Resource r ;
public Output(Resource r){
this.r = r;
}
public void run() {
while(true){
synchronized(r){
//判断标记,是false,等待
if(!r.flag){
try{r.wait();}catch(Exception ex){}
}
System.out.println(r.name+".."+r.sex);
//标记改成false,唤醒对方线程
r.flag = false;
r.notify();
}
}
}
}
/*
* 开启输入线程和输出线程,实现赋值和打印值
*/
public class ThreadDemo{
public static void main(String[] args) {
Resource r = new Resource();
Input in = new Input(r);
Output out = new Output(r);
Thread tin = new Thread(in);
Thread tout = new Thread(out);
tin.start();
tout.start();
}
}复制代码
输出结果如下：（完成了协同工作，赋值完后输出，输出完后赋值的目的）
