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();
}
}複製代碼
輸出結果如下：（完成了協同工作，賦值完後輸出，輸出完後賦值的目的）