java学习笔记（十二）-- 线程同步与死锁
一 线程的同步 ***************
同步问题：每一个线程对象轮番抢占共享资源带来的问题
首先看一段代码：
class MyThread implements Runnable{
private int ticket=10;
@Override
public void run() {
while (this.ticket>0){
try{
//模拟网络延迟
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+
",还有"+this.ticket--+"张票");
}
}
}
public class Test2 {
public static void main(String[] args) throws InterruptedException {
MyThread mt=new MyThread();
new Thread(mt,"黄牛A").start();
new Thread(mt,"黄牛B").start();
new Thread(mt,"黄牛C").start();
}
}
这时会发现运行到最后时会出现如下结果，当只剩下一张票的时候，却被三个人拿去同时买：
......
黄牛B,还有1张票
黄牛C,还有0张票
黄牛A,还有-1张票上面出现现象就可以称之为不同步操作，其唯一好处就是处理速度快（多个线程并发执行）
1 同步处理
1.1 使用synchronize关键字（内建锁，JDK1.0作为关键字提供的同步手段）来处理同步问题 对象锁一定要清楚锁的对象
synchronize处理同步有两种模式：同步代码块，同步方法
同步代码块：（推荐使用，锁粒度较细）要使用同步代码块必须设置一个锁定的对象，一般可以锁当前对象this
同一时刻只能有一个线程进入代码块，方法内仍然是多线程
synchronized（this）{
//需要同步代码块
}
class MyThread implements Runnable{
private int ticket=1000;
@Override
public void run() {
for(int i=0;i<1000;i++){
synchronized (this){
if(this.ticket>0){
System.out.println(Thread.currentThread().getName()+
",还有"+this.ticket--+"张票");
}
}
}
}
}
public class Test2 {
public static void main(String[] args) throws InterruptedException {
MyThread mt=new MyThread();
new Thread(mt,"黄牛A").start();
new Thread(mt,"黄牛B").start();
new Thread(mt,"黄牛C").start();
}
}
会发现执行结果中没有负数：
......
黄牛B,还有3张票
黄牛B,还有2张票
黄牛B,还有1张票同步方法：在方法上添加synchronize关键字，表示此方法只有一个线程能进入。隐式锁对象，this
同一时刻只有一个线程能进入此方法
范例：
class MyThread implements Runnable{
private int ticket=1000;
@Override
public void run() {
for(int i=0;i<1000;i++){
if(this.ticket>0){
this.sala();
}
}
}
public synchronized void sala(){
if(this.ticket>0){
try {
//模拟网络延迟
Thread.sleep(20);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+
",还有"+this.ticket--+"张票");
}
}
}
public class Test2 {
public static void main(String[] args) throws InterruptedException {
MyThread mt=new MyThread();
new Thread(mt,"黄牛A").start();
new Thread(mt,"黄牛B").start();
new Thread(mt,"黄牛C").start();
}
}
会发现执行结果中没有负数：
......
黄牛C,还有3张票
黄牛A,还有2张票
黄牛A,还有1张票同步的缺点：虽然可以保证数据的完整性（线程安全操作），但是其执行的速度回很慢 StringBuilder 和 StringBuffer
- StringBuffer JDK1.0 ，采用同步处理，线程安全，效率较低
- StringBuilder JDK1.5，采用异步处理，线程不安全，效率较高
1.2 关于synchronized的额外说明
①实际上synchronized（this）
非static的synchronized方法，只能防止多个线程同时执行同一个对象的同步代码块。
synchronized叫对象锁（默认只能锁一个对象），锁的是对象本身即this。
范例：观察synchronized的额外说明
class Sync{
public synchronized void test(){ //默认锁的是当前对象
System.out.println("test方法开始，当前线程"+Thread.currentThread().getName());
try{
Thread.sleep(1000);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("test方法结束，当前线程为"+Thread.currentThread().getName());
}
}
class MyThread extends Thread{
//使用static只实例化一个Sync对象，这样三个线程使用同一块锁
//static Sync sync=new Sync();
@Override
public void run() {
Sync sync=new Sync();
sync.test();
}
}
public class Test2 {
public static void main(String[] args) {
for(int i=0;i<3;i++){
Thread thread=new MyThread();
thread.start();
}
}
}
观察结果，三个线程同时开始，同时结束：
test方法开始，当前线程Thread-0
test方法开始，当前线程Thread-1
test方法开始，当前线程Thread-2
test方法结束，当前线程为Thread-0
test方法结束，当前线程为Thread-1
test方法结束，当前线程为Thread-2若要锁住这段代码还有三中思路：
范例: 锁同一个对象
class Sync{
public synchronized void test(){
System.out.println("test方法开始，当前线程"+Thread.currentThread().getName());
try{
Thread.sleep(1000);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("test方法结束，当前线程为"+Thread.currentThread().getName());
}
}
class MyThread extends Thread{
private Sync sync;
public MyThread(Sync sync){
this.sync=sync;
}
@Override
public void run() {
this.sync.test();
}
}
public class Test2 {
public static void main(String[] args) {
//实例化一个Sync对象
Sync sync=new Sync();
for(int i=0;i<3;i++){
Thread thread=new MyThread(sync);
thread.start();
}
}
}对象锁与全局锁：
synchronized默认对象锁，锁的是当前对象而非代码块
全局锁锁的是真正代码段，与对象无关！
实现全局锁的两种方式：
1.在同步代码段锁Class对象
2.使用static synchronized方法
范例：使用全局锁，锁的是类而不是this对象
class Sync{
public void test(){
//使用全局锁，锁的是以下代码段，与对象无关
synchronized (Sync.class){
System.out.println("test方法开始，当前线程"+Thread.currentThread().getName());
try{
Thread.sleep(1000);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("test方法结束，当前线程为"+Thread.currentThread().getName());
}
}
}
class MyThread extends Thread{
@Override
public void run() {
Sync sync = new Sync() ;
sync.test();
}
}
public class Test2 {
public static void main(String[] args) {
for(int i=0;i<3;i++){
Thread thread=new MyThread();
thread.start();
}
}
}static synchronized方法，static方法可以直接类名加方法名调用，方法中无法使用this，所以它锁的不是this，而是类 的Class对象，所以，static synchronized方法也相当于全局锁，相当于锁住了代码段。
范例：使用static synchronized方法
class Sync{
//此时锁的为一下代码块，与对象无关
public static synchronized void test(){ //默认锁的是当前对象
System.out.println("test方法开始，当前线程"+Thread.currentThread().getName());
try{
Thread.sleep(1000);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("test方法结束，当前线程为"+Thread.currentThread().getName());
}
}
class MyThread extends Thread{
@Override
public void run() {
Sync sync=new Sync();
sync.test();
}
}
public class Test2 {
public static void main(String[] args) {
for(int i=0;i<3;i++){
Thread thread=new MyThread();
thread.start();
}
}
}范例：看一段代码（ **** 重要 **** ）典型面试题
class MyThread implements Runnable{
private ThreadTest test;
public MyThread(ThreadTest test){
super();
this.test=test;
}
@Override
public void run() {
if(Thread.currentThread().getName().equals("Thread-1")){
this.test.testA();
}else if(Thread.currentThread().getName().equals("Thread-2")){
this.test.testB();
}
}
}
class ThreadTest{
public synchronized void testA(){
System.out.println(Thread.currentThread().getName()+"tsetA方法");
while(true){}
}
public synchronized void testB(){
System.out.println(Thread.currentThread().getName()+"tsetB方法");
}
}
public class Test2 {
public static void main(String[] args) throws InterruptedException {
ThreadTest test=new ThreadTest();
MyThread mythread=new MyThread(test);
Thread thread1=new Thread(mythread);
Thread thread2=new Thread(mythread);
thread1.start();
Thread.sleep(1000);
thread2.start();
}
}线程2是否能进入到testB中吗？
锁的是当前对象，两个同步方法锁的是同一个对象
同一个对象，当一个类中有两个同步方法时，有一个线程已经进了一个同步方法时，另外一个线程绝对不能进入另外的同步方法
如果有一个同步方法一个普通方法，另外一个线程可以进到普通方法
1.3 对象锁（monitor）机制 --- JDK6之前的synchronized（重量级锁）
同步代码块：执行同步代码块后首先要执行monitorenter指令，退出时执行monitorexit指令。
使用内建锁（synchronized）进行同步，关键在于获取指定锁对象monitor对象，当线程获取monitor后才能继续向下执行，否则就只能等待。这个获取过程是互斥的，即同一时刻只有一个线程能够获取到对象monitor。
通常一个monitorenter指令会包含若干个monitorexit指令。原因在于JVM需要确保在正常执行路径以及异常执行路径上都能正确的解锁，任何情况下都能够解锁。
同步方法：当使用所有synchronized标记方法时，编译后字节码中方法的访问标记多了一个 ACC_SYNCHRONIZED。该标记表示，进入该方法时，JVM需要进行monitorenter操作，退出该方法时，无论是否正常返回，JVM均需要进行monitorexit操作。
当执行monitorenter时，如果目标锁对象的monitor计数器为0，表示此对象没有被任何其他对象所持有。此时JVM会将该锁对象的持有线程设置为当前线程，并且有计数器+1；如果目标锁对象计数器不为0，判断锁对象的持有线程是否是当前线程，如果是再次将计数器+1（锁的可重入性），如果锁对象的持有线程不是当前线程，当前线程需要等待，直至持有线程释放锁。
当执行monitorexit时，JVM会将锁对象的计数器-1，当计数器减为0时，代表该锁已经被释放。
JDK1.5提供的Lock锁（了解即可 ）（任然是对象锁）
范例：使用ReentrantLock进行同步处理，在需要上锁的时候Lock,在finally中unLock
class MyThread implements Runnable{
private int ticket=100;
private Lock ticketLock=new ReentrantLock();
@Override
public void run() {
for(int i=0;i<100;i++){
try{
ticketLock.lock();
if(this.ticket>0) {
System.out.println(Thread.currentThread().getName() +
"还剩下：" + this.ticket-- + "票");
}
}finally{
//手工释放锁
ticketLock.unlock();
}
}
}
}
public class Test2 {
public static void main(String[] args) throws InterruptedException {
MyThread mt=new MyThread();
Thread thread1=new Thread(mt,"黄牛1");
Thread thread2=new Thread(mt,"黄牛2");
Thread thread3=new Thread(mt,"黄牛3");
thread1.setPriority(Thread.MIN_PRIORITY);
thread2.setPriority(Thread.MAX_PRIORITY);
thread3.setPriority(Thread.MAX_PRIORITY);
thread1.start();
thread2.start();
thread3.start();
}
}