Java线程锁、死锁问题

线程锁案例

假设有有一个买票系统，多个线程同时抢票

Ticket.java

package com.wdy.thread;
/**
 * 卖票系统
 * @author wdy
 */
public class Ticket {
    private int num=100;   
    public synchronized void sold(String name) {
    	System.out.println(name+"卖出一张后还剩："+(--num));
    }
    
    public int getNum() {
    	return num;
    }
}

TicketThread.java

package com.wdy.thread;
public class TicketThread extends Thread {
      private Ticket ticket;
      private String name;
      
	public TicketThread(Ticket ticket,String name) {
		this.ticket=ticket;
		this.name=name;
	}
      
	@Override
	public void run() {
		while(ticket.getNum()>0) {
			ticket.sold(name);
			try {
				sleep(300);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}     
}

TicketTest.java

package com.wdy.thread;
public class TicketTest {
      public static void main(String[] args) {
		Ticket ticket =new Ticket();
		
		TicketThread a=new TicketThread(ticket, "A");
		TicketThread b=new TicketThread(ticket, "B");
		TicketThread c=new TicketThread(ticket, "C");
	    
		a.start();
		b.start();
		c.start();   
      }
}

结果截图：出现一张票被卖了好几次，线程不安全。

解决方式1 synchronized

synchronized

synchronized又称为同步锁.修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

• 当两个线程并发访问同一对象中的synchroned(this)代码块时，一个时间内只能有一个线程得到执行。另外一个线程必须等待当前线程执行完这个代码块以后才能执行该代码。

• 当一个线程访问对象的syncronlzed代码块时，另外一个线程仍然能访问非syochronlted修饰的代码块。

• 当一个线程访问到synchronized代码块时，其它线程对对象中所有的其它synchronized同步代码块访问被阻塞。

• 同一时间只有一个线程能够取得对象的锁。

特点：

• 不需要手动释放和开启锁
• 对象之间是互斥的关系

在sold（）卖票方法加上synchronized关键字

package com.wdy.thread;

/**
 * 卖票系统
 * @author wdy
 */

public class Ticket {
    private int num=100;
    
    public synchronized void sold(String name) {
    	System.out.println(name+"卖出一张后还剩："+(--num));
    }
    
    public int getNum() {
    	return num;
    }
}

执行结果：正常卖票，线程安全。

解决方式2 ReetrantLock

ReentrantLock

Lock是一个接口提供无条件、可轮训的、定时的、可中断的锁获取操作，所以加锁和解锁的方法都是显示的。ReentrantLock是Lock的实现类。

特点：

• 使用灵活，但必须有释放锁的动作
• 手动释放和开启锁
• 只适用于代码块锁

synchronized和ReentrantLock的比较

下一篇博客

修改Ticket.java
ReentrantLock

package com.wdy.thread;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 卖票系统
 * @author wdy
 */

public class Ticket {
    private static final ReentrantLock lock = new ReentrantLock(); 
	private int num=100; 
	
    public void sold(String name) {
    	lock.lock();
    	try {
    	System.out.println(name+"卖出一张后还剩："+(--num));
    	}finally {
    		lock.unlock();
    	}
    }
       
    public int getNum() {
    	return num;
    }
}

执行结果：

死锁问题

出现其中一个条件就会出现死锁问题

• 互斥条件: 一个资源每次只能被-个进程使用， 即在段时间内某资源仅为一个进程所占有。 此时若有其他进程请求该资源，则请求进程只能等待。
• 请求与保持条件: 进程已经保持了至少个资源， 但又提出了新的资源请求，而该资源已被其他进程占有,此时请求进程被阻塞,但对自己己获得的资源保持不放。
• 不可剥夺条件: 进程所获得的资源在未使用完毕之前，不能被其他进程强行夺走，即只能由获得该资源的进程自己来释放(只能是主动释放)。
• 循环等待条件: 若干进程间形成首尾相按循环等待资源的关系

循环等待条件的案例

拆包和封包的案例

• 拆包

package com.wdy.thread;
public class ThreadTest01 {

	public static void main(String[] args) {
		Integer x=3;
		int y=x; //是否为原子性操作？（非原子性，原子性是直接执行，不分步骤）
     //x如何拆包为y? 通过调用x的intValue()方法 ，再赋值给y。转为int类型。
	 //y=x.intValue(); 通过cmd窗口输入javap-c Test 执行反编译，可查看调用何种方法
	}
}

• 封包

package com.wdy.thread;
public class ThreadTest04{
	public static void main(String[] args) {
		int x=3;
		Integer y=x; //是否为原子性操作？（非原子性，原子性是直接执行，不分步骤）
     //x如何封包为y? x调用的Integer.valueOf()方法 ，再赋值给y。Integer转为int类型。
	 // 通过cmd窗口输入javap-c Test 执行反编译，可查看调用何种方法
	}
}

ThreadLocal 线程本地化

ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每个线程都可以独立地改变自己的副本，而不影响其它线程所对应的副本。

ThreadLocal底层是Map，Map的key类比为当前线程的id，value是赋的初始值。

• 优点：可以保证线程安全
• 缺点：每个线程都需要拷贝一份，增加内存空间

package com.wdy.thread;

public class ThreadLocalDemo {

	private static final ThreadLocal<Integer> local = new ThreadLocal<Integer>() {
		protected Integer initialValue() {//初始第一个值为0
			return 0;
		}
	};
	
	public static class DemoThread extends Thread{
		@Override
		public void run() {
			for(int i=0;i<5;i++) {
				int curr = local.get();
				local.set(curr+1);
				System.out.println(this.getName()+":" + local.get());
			}
		}
	}
	
	public static void main(String[] args) {
		Thread t1 = new DemoThread();
		t1.setName("A");
		Thread t2 = new DemoThread();
		t2.setName("B");
		Thread t3 = new DemoThread();
		t3.setName("C");
		
		t1.start();
		t2.start();
		t3.start();
	}
}

结果如下，各个线程执行完1-5的打印，互不影响，线程安全。