public class Example {
    public static void main(String[] args)  {
        final InsertData insertData = new InsertData();
        new Thread() {
            public void run() {
                insertData.insert(Thread.currentThread());
            };
        }.start();
        new Thread() {
            public void run() {
                insertData.insert(Thread.currentThread());
            };
        }.start();
    }  
}
class InsertData {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    public void insert(Thread thread){
        for(int i=0;i<5;i++){
            System.out.println(thread.getName()+"在插入数据"+i);
            arrayList.add(i);
        }
    }
}

这段代码的执行是随机的（每次结果都不一样）：

Thread-0在插入数据0
Thread-1在插入数据0
Thread-1在插入数据1
Thread-1在插入数据2
Thread-1在插入数据3
Thread-1在插入数据4
Thread-0在插入数据1
Thread-0在插入数据2
Thread-0在插入数据3
Thread-0在插入数据4

现在我们加上synchronized关键字来看看执行结果：

public synchronized void insert(Thread thread){
     for(int i=0;i<5;i++){
        System.out.println(thread.getName()+"在插入数据"+i);
        arrayList.add(i);
    }
}
输出：

Thread-0在插入数据0
Thread-0在插入数据1
Thread-0在插入数据2
Thread-0在插入数据3
Thread-0在插入数据4
Thread-1在插入数据0
Thread-1在插入数据1
Thread-1在插入数据2
Thread-1在插入数据3
Thread-1在插入数据4

可以发现，线程1会等待线程0插入完数据之后再执行，说明线程0和线程1是顺序执行的。

从这两个示例中，我们可以知道synchronized关键字可以实现方法同步互斥访问。

在使用synchronized关键字的时候有几个问题需要我们注意：

在线程调用synchronized的方法时，其他synchronized的方法是不能被访问的，道理很简单，一个对象只有一把锁；
当一个线程在访问对象的synchronized方法时，其他线程可以访问该对象的非synchronized方法，因为访问非synchronized不需要获取锁，是可以随意访问的；
如果一个线程A需要访问对象object1的synchronized方法fun1，另外一个线程B需要访问对象object2的synchronized方法fun1，即使object1和object2是同一类型），也不会产生线程安全问题，因为他们访问的是不同的对象，所以不存在互斥问题。

synchronized代码块

synchronized代码块对于我们优化多线程的代码很有帮助，首先我们来看看它长啥样：

synchronized(synObject) {

}

当在某个线程中执行该段代码时，该线程会获取到该对象的synObject锁，此时其他线程无法访问这段代码块，synchronized的值可以是this代表当前对象，也可以是对象的属性，用对象的属性时，表示的是对象属性的锁。

有了synchronized代码块，我们可以将上述添加数据的例子修改成如下两种形式：

class InsertData {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    public void insert(Thread thread){
        synchronized (this) {
            for(int i=0;i<100;i++){
                System.out.println(thread.getName()+"在插入数据"+i);
                arrayList.add(i);
            }
        }
    }
}
class InsertData {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    private Object object = new Object();
    public void insert(Thread thread){
        synchronized (object) {
            for(int i=0;i<100;i++){
                System.out.println(thread.getName()+"在插入数据"+i);
                arrayList.add(i);
            }
        }
    }
}

上述代码就是synchronized代码块添加锁的两种方式，可以发现添加synchronized代码块，要比直接在方法上添加synchronized关键字更加灵活。

当我们用sychronized关键字修饰方法时，这个方法只能同时让一个线程访问，但是有时候很可能只有一部分代码需要同步，而这个时候使用sychronized关键字修饰的方法是做不到的，但是使用sychronized代码块就可以实现这个功能。

并且如果一个线程执行一个对象的非static synchronized方法，另外一个线程需要执行这个对象所属类的static synchronized方法，此时不会发生互斥现象，因为访问static synchronized方法占用的是类锁，而访问非static synchronized方法占用的是对象锁，所以不存在互斥现象。

来看一段代码：

public class Test {
    public static void main(String[] args)  {
        final InsertData insertData = new InsertData();
        new Thread(){
            public void run() {
                insertData.insert();
            }
        }.start(); 
        new Thread(){
            public void run() {
                insertData.insert1();
            }
        }.start();
    }  
}
class InsertData { 
    public synchronized void insert(){
        System.out.println("执行insert");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackT\frace();
        }
        System.out.println("执行insert完毕");
    }
    public synchronized static void insert1() {
        System.out.println("执行insert1");
        System.out.println("执行insert1完毕");
    }
}
执行结果：

执行insert
执行insert1
执行insert1完毕
执行insert完毕

编程要求

请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下：

使num变量在同一时刻只能有一个线程可以访问。

package step2;

public class Task {

	public static void main(String[] args) {
		
		final insertData insert = new insertData();
		
		for (int i = 0; i < 3; i++) {
			new Thread(new Runnable() {
				public void run() {
					insert.insert(Thread.currentThread());
				}
			}).start();
		}				
	}
}
class insertData{
	
	public static int num =0;
	
	/********* Begin *********/
	public synchronized void insert(Thread thread){
		for (int i = 0; i <= 5; i++) {
			num++;
			System.out.println(num);
		}
	}

	/********* End *********/
}

第3关：使用线程锁（Lock）实现线程同步

相关知识

上一关我们谈到了synchronized关键字，synchronized关键字主要用来同步代码，实现同步互斥访问，也就是在同一时刻只能有一个线程访问临界资源。从而解决线程的安全问题。

如果一个方法或者代码块被synchronized关键字修饰，当线程获取到该方法或代码块的锁，其他线程是不能继续访问该方法或代码块的。

而其他线程要能访问该方法或代码块，就必须要等待获取到锁的线程释放这个锁，而在这里释放锁只有两种情况：

线程执行完代码块，自动释放锁；
程序报错，jvm让线程自动释放锁。

可能会有一种情况，当一个线程获取到对象的锁，然后在执行过程中因为一些原因（等待IO，调用sleep方法）被阻塞了，这个时候锁还在被阻塞的线程手中，而其他线程这个时候除了等之外，没有任何办法，我们想一想这样子会有多影响程序的效率。

synchronized是Java提供的关键字，使用起来非常方便，不过在有些情况下，它是具有很多局限性的。因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断），通过Lock就可以办到。

在比如，当多个线程操作同一个文件的时候，同时读写是会冲突的，同时写也是会冲突的，但是同时读是不会发生冲突的，而我们如果用synchronized来实现同步，就会出现一个问题：

如果多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等待无法进行读操作。

因此就需要一种机制来使得多个线程都只是进行读操作时，线程之间不会发生冲突，而通过Lock就可以办到。

总的来说Lock要比synchronized提供的功能更多，可定制化的程度也更高，Lock不是Java语言内置的，而是一个类。

Lock接口

我们来了解一下反复提到的Lock，首先我们来查看它的源码：

public interface Lock {

void lock();

void lockInterruptibly() throws InterruptedException;

boolean tryLock();

boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

void unlock();

Condition newCondition();

}

可以发现Lock是一个接口，其中：lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()方法是用来获取锁的，unlock()方法是用来释放锁的。

首先lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。

由于在前面讲到如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。

一个使用Lock的例子：

Lock lock = ...;

lock.lock();

try{

//处理任务

}catch(Exception ex){

}finally{

lock.unlock(); //释放锁

}

tryLock()顾名思义，是用来尝试获取锁的，并且该方法有返回值，表示获取成功与否，获取成功返回true，失败返回false，从方法可以发现，该方法如果没有获取到锁时不会继续等待的，而是会直接返回值。

tryLock()的重载方法tryLock(long time, TimeUnit unit)功能类似，只是这个方法会等待一段时间获取锁，如果过了等待时间还未获取到锁就会返回false，如果在等待时间之内拿到锁则返回true。

所以我们经常这样使用：

Lock lock = ...;

if(lock.tryLock()) {

try{

//处理任务

}catch(Exception ex){

}finally{

lock.unlock(); //释放锁

}

}else {

//如果不能获取锁，则直接做其他事情

}

lock()方法的正确使用

因为Lock是一个接口所以我们在编程时一般会使用它的实现类，ReentrantLock是Lock接口的一个实现类，意思是“可重入锁”，接下来我们通过一个例子来学习lock()方法的正确使用方式。

示例1：

public class Test {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    public static void main(String[] args)  {
        final Test test = new Test();
        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
    }  
    public void insert(Thread thread) {
        Lock lock = new ReentrantLock();    //注意这个地方
        lock.lock();
        try {
            System.out.println(thread.getName()+"得到了锁");
            for(int i=0;i<5;i++) {
                arrayList.add(i);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }finally {
            System.out.println(thread.getName()+"释放了锁");
            lock.unlock();
        }
    }
}
输出：

Thread-1得到了锁
Thread-0得到了锁
Thread-0释放了锁
Thread-1释放了锁

结果可能出乎你的意料，不对呀，按道理应该是一个线程得到锁其他线程不能获取锁了的啊，为什么会这样呢？是因为insert()方法中lock变量是一个局部变量。THread-0和Thread-1获取到的是不同的锁，这样不会造成线程的等待。

那怎么才能利用lock()实现同步呢？相信你已经想到了，只要将Lock定义成全局变量就可以了。

public class Test {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    private Lock lock = new ReentrantLock();    //注意这个地方
    public static void main(String[] args)  {
        final Test test = new Test();
        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
    }  
    public void insert(Thread thread) {
        lock.lock();
        try {
            System.out.println(thread.getName()+"得到了锁");
            for(int i=0;i<5;i++) {
                arrayList.add(i);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }finally {
            System.out.println(thread.getName()+"释放了锁");
            lock.unlock();
        }
    }
}
结果：

Thread-0得到了锁
Thread-0释放了锁
Thread-1得到了锁
Thread-1释放了锁

这样就是我们预期的结果了。

很多时候我们为了提高程序的效率不希望线程为了等待锁而一直阻塞，这个时候可以使用tryLock()可以达到目的。

示例，将之前的insert()方法修改成tryLock()实现：

 public void insert(Thread thread) {
        if(lock.tryLock()) {
            try {
                System.out.println(thread.getName()+"得到了锁");
                for(int i=0;i<5;i++) {
                    arrayList.add(i);
                }
            } catch (Exception e) {
                // TODO: handle exception
            }finally {
                System.out.println(thread.getName()+"释放了锁");
                lock.unlock();
            }
        } else {
            System.out.println(thread.getName()+"获取锁失败");
        }
}
输出：

Thread-0得到了锁
Thread-1获取锁失败
Thread-0释放了锁

编程要求

请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充。

package step3;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Task {

	public static void main(String[] args) {
		final Insert insert = new Insert();
		Thread t1 = new Thread(new Runnable() {
			public void run() {
				insert.insert(Thread.currentThread());
			}
		});
		Thread t2 = new Thread(new Runnable() {
			public void run() {
				insert.insert(Thread.currentThread());
			}
		});
		Thread t3 = new Thread(new Runnable() {
			public void run() {
				insert.insert(Thread.currentThread());
			}
		});
		// 设置线程优先级
		t1.setPriority(Thread.MAX_PRIORITY);
		t2.setPriority(Thread.NORM_PRIORITY);
		t3.setPriority(Thread.MIN_PRIORITY);
		t1.start();
		t2.start();
		t3.start();
	}
}
class Insert {
	public static int num;
	// 在这里定义Lock
    private Lock lock = new ReentrantLock(); 

	public void insert(Thread thread) {
		/********* Begin *********/
		if(lock.tryLock()){
			try{ //处理任务
				System.out.println(thread.getName()+"得到了锁");
				for (int i = 0; i < 5; i++) {
					num++;
					System.out.println(num);
				}
			}finally{
				System.out.println(thread.getName()+"释放了锁");
				lock.unlock();   //释放锁
			}
		}else{ //如果不能获取锁，则直接做其他事情
			System.out.println(thread.getName()+"获取锁失败");
		}
		/********* End *********/
	}
}

第4关：使用volatile实现变量的可见性

编程要求

请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充。 ####测试说明

预期输出：10000。

提示：可以使用两种方式实现原子性，所以本关有多种方式都可以通关。

package step4;

public class Task {
	public volatile int inc = 0;
//请在此添加实现代码
/********** Begin **********/
	public synchronized void increase() {
		inc++;
}
/********** End **********/
	public static void main(String[] args) {
		final Task test = new Task();
		for (int i = 0; i < 10; i++) {
			new Thread() {
				public void run() {
					for (int j = 0; j < 1000; j++)
						test.increase();
				};
			}.start();
		}
		while (Thread.activeCount() > 1) // 保证前面的线程都执行完
			Thread.yield();
		System.out.println(test.inc);
	}
}

Educoder/头歌JAVA——JAVA高级特性：多线程基础（3）线程同步

第1关：并发编程的三个概念

任务描述

相关知识

1.原子性

2.可见性

3.有序性

编程要求

第2关：使用synchronized关键字同步线程

相关知识

并发编程什么时候会出现安全问题

怎么解决线程的安全问题呢？

synchronized关键字

synchronized代码块

编程要求

第3关：使用线程锁（Lock）实现线程同步

相关知识

Lock接口

lock()方法的正确使用

编程要求

第4关：使用volatile实现变量的可见性

相关知识

什么是 volatile 关键字

volatile可以保证原子性吗

编程要求

猜你喜欢