多线程-synchronized

首先搞清楚一个问题：Runnable和Thread的区别

在java中可有两种方式实现多线程。a、继承Thread类，b、实现Runnable接口；
a方式只能继承一个父类，b方式避免单继承的局限，一个类可以继承多个接口。
b方式适合于资源的共享。
重点讲解一下资源共享。以卖票程序为例

class MyRunnable implements Runnable {

		private  int ticket = 10;
		
		public synchronized void upTicket() {
			System.out.println(Thread.currentThread().getName()+",ticket:" + ticket);
			ticket--;
		}
		public void run() {
			while(ticket>0) {
				upTicket();
				try {
					Thread.sleep(1);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}

	}

	class MyThread extends Thread {

		private int ticket = 10;
		
		public synchronized void upTicket() {
			System.out.println(Thread.currentThread().getName()+",ticket:" + ticket);
			ticket--;
		}

		public void run() {
			while(ticket>0) {
				upTicket();
				try {
					Thread.sleep(1);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

	public void testRunnable() {
		MyRunnable mr = new MyRunnable();
		new Thread(mr).start();
		new Thread(mr).start();
		new Thread(mr).start();
	}
	
	public void testThread() {
		MyThread t1 = new MyThread();
		t1.start();
		MyThread t2 = new MyThread();
		t2.start();
		MyThread t3 = new MyThread();
		t3.start();
	}

testRunnable()方法打印结果：

Thread-0,ticket:10
Thread-2,ticket:9
Thread-1,ticket:8
Thread-2,ticket:7
Thread-0,ticket:6
Thread-1,ticket:5
Thread-2,ticket:4
Thread-0,ticket:3
Thread-1,ticket:2
Thread-0,ticket:1
Thread-2,ticket:0

testThread()方法打印结果：

Thread-1,ticket:10
Thread-1,ticket:9
Thread-2,ticket:10
Thread-2,ticket:9
Thread-1,ticket:8
Thread-0,ticket:10
Thread-2,ticket:8
Thread-1,ticket:7
Thread-0,ticket:9
Thread-2,ticket:7
Thread-1,ticket:6
Thread-0,ticket:8
Thread-1,ticket:5
Thread-2,ticket:6
Thread-2,ticket:5
Thread-1,ticket:4
Thread-0,ticket:7
Thread-2,ticket:4
Thread-1,ticket:3
Thread-0,ticket:6
Thread-1,ticket:2
Thread-0,ticket:5
Thread-2,ticket:3
Thread-1,ticket:1
Thread-0,ticket:4
Thread-2,ticket:2
Thread-0,ticket:3
Thread-2,ticket:1
Thread-0,ticket:2
Thread-0,ticket:1

从结果可以分析出：

testThread() 每个线程都各卖了10张，共卖了30张票，没有达到资源共享
testRunnable() 虽然现在程序中有三个线程，但是一共卖了10张票，也就是说使用Runnable实现多线程可以达到资源共享目的。

关键问题：多个线程是同时访问同一个对象还是多个对象。

synchronized当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。
看下面的代码：

class Sync {  
    public synchronized void go() {  
    	System.out.println(Thread.currentThread().getName()+",begin..");  
        try {  
            Thread.sleep(1000);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        System.out.println(Thread.currentThread().getName()+",end..");  
    }  
}  

class MyRunnable implements Runnable{
	public void run() {
		Sync sync = new Sync();  
		sync.go();  
	}
}

public class ThreadTest {
	public static void main(String[] args){
		for (int i = 0; i < 3; i++) {  
			MyRunnable runnable = new MyRunnable();  
            new Thread(runnable).start();
        }  
	}
}

运行结果：

Thread-2,begin..
Thread-0,begin..
Thread-1,begin..
Thread-0,end..
Thread-1,end..
Thread-2,end..

但是还是同时运行起来，貌似synchronized没起作用。

所以：synchronized(this)以及非static的synchronized方法。只能防止多个线程同时执行同一个对象的这个代码段。注意：是同一个对象哦。

改进：

class Sync {
	public synchronized void go() {
		System.out.println(Thread.currentThread().getName() + ",begin..");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName() + ",end..");
	}
}

class MyRunnable implements Runnable {
	private Sync sync;

	public MyRunnable(Sync sync) {
		this.sync = sync;
	}

	public void run() {
		sync.go();
	}
}

public class ThreadTest {
	public static void main(String[] args) {
		 Sync sync = new Sync();
		for (int i = 0; i < 3; i++) {
			MyRunnable runnable = new MyRunnable(sync);
			new Thread(runnable).start();
		}
	}
}

运行结果：

Thread-0,begin..
Thread-0,end..
Thread-2,begin..
Thread-2,end..
Thread-1,begin..
Thread-1,end..

可以看到，此时的synchronized方法和synchronized代码段就都起了作用。
那么，如果真的想锁住这段代码，要怎么做？也就是，如果还是最开始的那段代码，每个线程new一个Sync对象，怎么才能让go方法不会被多线程执行。

解决也很简单，只要锁住同一个对象不就行了。例如，synchronized后的括号中锁一个static final对象，这样就行了。这样是没问题，但是，比较多的做法是让synchronized锁这个类对应的Class对象。

class Sync {
	public void go() {
		synchronized (Sync.class) {
			System.out.println(Thread.currentThread().getName() + ",begin..");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + ",end..");
		}
	}
}

class MyRunnable implements Runnable {
	public void run() {
		Sync sync = new Sync();
		sync.go();
	}
}

public class ThreadTest {
	public static void main(String[] args) {
		for (int i = 0; i < 3; i++) {
			MyRunnable runnable = new MyRunnable();
			new Thread(runnable).start();
		}
	}
}

运行结果：

Thread-0,begin..
Thread-0,end..
Thread-1,begin..
Thread-1,end..
Thread-2,begin..
Thread-2,end..

最后说说static synchronized，实际上static方法可以直接类名加方法名调用，方法里面没有this这个概念，所以，static synchronized方法也相当于全局锁，相当于锁住了代码段。