一、Synchronized
synchronized中文解释是同步，那么什么是同步呢，解释就是程序中用于控制不同线程间操作发生相对顺序的机制，通俗来讲就是2点，第一要有多线程，第二当多个线程同时竞争某个资源的时候会有先后顺序。在java中有三种写synchronized的方式：
第一种：写在普通方法的前面，这种表示对实例对象加锁第二种：写在静态方法前面，这种表示对类对象加锁第三种：写在代码块中，锁是Synchonized括号里配置的对象(可能是实例对象，也可能是类对象)
总体说来就2种，一种就是锁实例对象，一种锁类对象。
锁实例对象就是当多个线程同时操作这个实例对象(针对的是特定的实例对象)的时候必须先获取锁，如果无法获取锁，则必须处于等待状态，而和锁类对象区别是，当多个线程同时操作的时候，任何以这个类对象实例化的对象都要获取锁才能操作。
看下面的例子：
public classSynchronized_Test {public static voidmain(String[] args){
Thread t1=new Thread(newMyRunnable());
Thread t2=new Thread(newMyRunnable());
t1.start();
t2.start();
}
}class MyRunnable implementsRunnable{private synchronized voidsynchMethodTest(){for(int i=0;i<10;i++)
System.out.println(Thread.currentThread().getName()+"synchMethodTest: "+i);
}public voidrun() {
synchMethodTest();
}
}
其输出结果为：
Thread-0synchMethodTest: 0Thread-1synchMethodTest: 0Thread-0synchMethodTest: 1Thread-1synchMethodTest: 1Thread-0synchMethodTest: 2Thread-1synchMethodTest: 2Thread-0synchMethodTest: 3Thread-1synchMethodTest: 3Thread-0synchMethodTest: 4Thread-1synchMethodTest: 4Thread-0synchMethodTest: 5Thread-1synchMethodTest: 5Thread-0synchMethodTest: 6Thread-1synchMethodTest: 6Thread-0synchMethodTest: 7Thread-1synchMethodTest: 7Thread-0synchMethodTest: 8Thread-1synchMethodTest: 8Thread-0synchMethodTest: 9Thread-1synchMethodTest: 9
因为synchronized是写在普通方法前，是对特定的实例对象加锁，t1，t2为两个不同的实例，
所以他们在执行synchronized方法时并不会互相阻塞对方。
如果将synchronized方法改成static方法，那么就是针对类对象加锁，任何以这个类对象实例化的对象都要获取锁才能操作，
t1，t2虽然是两个不同的实例，但都是同一个类对象的实例，所以当t1取得锁开始执行synchronized方法后，就会阻塞t2，
t2需要取得锁之后才能执行，如下：
public classSynchronized_Test {public static voidmain(String[] args){
Thread t1=new Thread(newMyRunnable());
Thread t2=new Thread(newMyRunnable());
t1.start();
t2.start();
}
}class MyRunnable implementsRunnable{private synchronized static voidsynchMethodTest(){for(int i=0;i<10;i++)
System.out.println(Thread.currentThread().getName()+"synchMethodTest: "+i);
}public voidrun() {
synchMethodTest();
}
}
输出结果为：
Thread-0synchMethodTest: 0Thread-0synchMethodTest: 1Thread-0synchMethodTest: 2Thread-0synchMethodTest: 3Thread-0synchMethodTest: 4Thread-0synchMethodTest: 5Thread-0synchMethodTest: 6Thread-0synchMethodTest: 7Thread-0synchMethodTest: 8Thread-0synchMethodTest: 9Thread-1synchMethodTest: 0Thread-1synchMethodTest: 1Thread-1synchMethodTest: 2Thread-1synchMethodTest: 3Thread-1synchMethodTest: 4Thread-1synchMethodTest: 5Thread-1synchMethodTest: 6Thread-1synchMethodTest: 7Thread-1synchMethodTest: 8Thread-1synchMethodTest: 9
t1执行完成，释放synchronized锁后，t2才能执行。如果在代码块中对类对象也是一样：
class MyRunnable implementsRunnable{private voidsynchMethodTest(){synchronized (MyRunnable.class){for(int i=0;i<10;i++)
System.out.println(Thread.currentThread().getName()+"synchMethodTest: "+i);
}
}public voidrun() {
synchMethodTest();
}
}
注意：
类方法中，synchronized锁住的是对象this,只有调用同一个对象的方法才需要获取锁。同时，
同一个对象中所有加了synchronize的方法只能一次调用一个；
静态方法中，synchronized锁的是整个类对象，类似于(X.class)，该类中所有加了synchronized的静态方法，一次只能调用一个。
比较下面两个例子：
public classSynchronized_Test {public static voidmain(String[] args){
Method method=newMethod();
Thread t1=new Thread(newMyRunnable1(method));
Thread t2=new Thread(newMyRunnable2(method));
t1.start();
t2.start();
}
}classMethod{public synchronized voidMethod1(){for(int i=0;i<10;i++)
System.out.println(Thread.currentThread().getName()+" Method1: "+i);
}public synchronized voidMethod2(){for(int i=0;i<10;i++)
System.out.println(Thread.currentThread().getName()+" Method2 "+i);
}
}class MyRunnable1 implementsRunnable{
Method method;
MyRunnable1(Method method){this.method=method;
}public voidrun() {
method.Method1();
}
}class MyRunnable2 implementsRunnable{
Method method;
MyRunnable2(Method method){this.method=method;
}public voidrun(){
method.Method2();
}
}
输出为：
Thread-0 Method1: 0Thread-0 Method1: 1Thread-0 Method1: 2Thread-0 Method1: 3Thread-0 Method1: 4Thread-0 Method1: 5Thread-0 Method1: 6Thread-0 Method1: 7Thread-0 Method1: 8Thread-0 Method1: 9Thread-1 Method2 0Thread-1 Method2 1Thread-1 Method2 2Thread-1 Method2 3Thread-1 Method2 4Thread-1 Method2 5Thread-1 Method2 6Thread-1 Method2 7Thread-1 Method2 8Thread-1 Method2 9
因为锁住的整个Method对象，在t1执行method1时，给method对象加锁，当t2要执行method2时，因为时synchronized方法，
所以首先要取得method对象的锁，才能执行。
public classSynchronized_Test {public static voidmain(String[] args){
Method method=newMethod();
Thread t1=new Thread(newMyRunnable1(method));
Thread t2=new Thread(newMyRunnable2(method));
t1.start();
t2.start();
}
}classMethod{public synchronized voidMethod1(){for(int i=0;i<10;i++)
System.out.println(Thread.currentThread().getName()+" Method1: "+i);
}public voidMethod2(){for(int i=0;i<10;i++)
System.out.println(Thread.currentThread().getName()+" Method2 "+i);
}
}class MyRunnable1 implementsRunnable{
Method method;
MyRunnable1(Method method){this.method=method;
}public voidrun() {
method.Method1();
}
}class MyRunnable2 implementsRunnable{
Method method;
MyRunnable2(Method method){this.method=method;
}public voidrun(){
method.Method2();
}
}
输出为：
Thread-0 Method1: 0Thread-1 Method2 0Thread-0 Method1: 1Thread-1 Method2 1Thread-0 Method1: 2Thread-1 Method2 2Thread-0 Method1: 3Thread-1 Method2 3Thread-0 Method1: 4Thread-1 Method2 4Thread-0 Method1: 5Thread-1 Method2 5Thread-0 Method1: 6Thread-1 Method2 6Thread-1 Method2 7Thread-1 Method2 8Thread-1 Method2 9Thread-0 Method1: 7Thread-0 Method1: 8Thread-0 Method1: 9
从结果可以看到，t1并没有阻塞t2的运行，因为t2执行的method2方法不带synchronized，所以在执行时并不需要先获得method对象的锁，执行的过程中也就不存在阻塞的情况。
二、wait、notify和notifyAll
wait、notify、notifyAll是Object对象的属性，并不属于线程。我们先解释这三个的一个很重要的概念
wait：使持有该对象的线程把该对象的控制权交出去，然后处于等待状态(这句话很重要，也就是说当调用wait的时候会释放锁并处于等待的状态)notify：通知某个正在等待这个对象的控制权的线程可以继续运行(这个就是获取锁，使自己的程序开始执行，最后通过notify同样去释放锁，并唤醒正在等待的线程)notifyAll:会通知所有等待这个对象控制权的线程继续运行(和上面一样，只不过是唤醒所有等待的线程继续执行)Obj.wait()与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait与notify是针对已经获取了Obj锁的对象来进行操作
下面来看一个生产者消费者模型，他们有一个缓冲区，缓冲区有最大限制，当缓冲区满的时候，生产者是不能将产品放入到缓冲区里面的，当然，当缓冲区是空的时候，消费者也不能从中拿出来产品，这就涉及到了在多线程中的条件判断，java中提供了wait和notify方法，他们可以在线程不满足要求的时候让线程让出来资源等待，当有资源的时候再notify他们让他们继续工作。
importjava.util.Date;importjava.util.LinkedList;importjava.util.List;classEventStorage {private intmaxSize;private Liststorage;publicEventStorage() {
maxSize= 10;
storage= new LinkedList();
}public synchronized voidset() {while(storage.size() ==maxSize) {try{
wait();
}catch(InterruptedException e) {
e.printStackTrace();
}
}
storage.add(newDate());
System.out.println("Set: "+storage.size());
notifyAll();
}public synchronized voidget() {while(storage.size() == 0) {try{
wait();
}catch(InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Get: "+storage.size()+" "+((LinkedList)storage).poll());
notifyAll();
}
}class Producer implementsRunnable {privateEventStorage storge;publicProducer(EventStorage storage) {this.storge =storage;
}public voidrun() {for(int i = 0; i < 100; i++) {
storge.set();
}
}
}class Consumer implementsRunnable {privateEventStorage storage;publicConsumer(EventStorage storage) {this.storage =storage;
}public voidrun() {for (int i = 0; i < 100; i++) {
storage.get();
}
}
}public classProducerAndConsumer {public static voidmain(String[] args){
EventStorage eventStorage=newEventStorage();
Thread t1=new Thread(newProducer(eventStorage));
Thread t2=new Thread(newConsumer(eventStorage));
t1.start();
t2.start();
}
}
扫一扫
1354
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
