Java多线程的两种实现方式的区别以及同步问题中的锁对象深刻解析

首先我们知道创建线程有两种方式：

1.继承Thread类；2.实现Runnable接口。

 

但是这两者并非完全一样的。下面谈谈区别：

因为Java并不支持多继承的（接口是可以多继承接口的。不过一般我们不提），但支持多实现。当一个类继承了父类，就不能再继承Thread类，只能通过实现接口的形式创建线程。

继承Runnable接口更加符合面向对象的思想。线程分为两部分，一是线程对象，二是线程任务。继承Thread类，线程对象和线程任务（run方法内的代码）耦合在一起。一旦创建了Thread类的子类对象，既是线程对象又是线程任务。而实现Runnable接口是将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。线程任务由传递的参数决定。Runable接口将线程对象和线程任务解耦。

第三个区别就是写同步函数的时候这两种方式有明显的差异

 

综上我们一般采用实现接口的形式来创建线程。

 

下面我们来说关于同步锁的问题。

Java的关于同步的问题有两种写法，一是代码块写同步，二是写同步函数。二者确是有区别的。

同步函数使用的锁是固定的this（即实现Runnable接口的类的对象），当线程任务只需要一个同步时，完全可以由同步函数来体现；

同步代码块的锁使用的是任意对象，当线程任务需要多同步时，必须用锁来区分。

下面给出详细的解释：首先看一个死锁的示例程序：

/* * 思路：死锁，嵌套同步时最简单的。 * 两个锁对象进行嵌套。两个线程执行同样的两个锁对象嵌套 */class MyLock {public static final Object LOCKA = new Object();public static final Object LOCKB = new Object();}class Test implements Runnable {private boolean flag;Test(boolean flag) {this.flag = flag;}public void run() {if (flag) {while (true) {synchronized (MyLock.LOCKA) {System.out.println(Thread.currentThread().getName()+ "...if.....LOCKA");synchronized (MyLock.LOCKB) {System.out.println(Thread.currentThread().getName()+ "...if.....LOCKB");}}}} else {while (true) {synchronized (MyLock.LOCKB) {System.out.println(Thread.currentThread().getName()+ "...else.....LOCKB");synchronized (MyLock.LOCKA) {System.out.println(Thread.currentThread().getName()+ "...else.....LOCKA");}}}}}}public class DeadLock {public static void main(String[] args) {Test test1 = new Test(true);Test test2 = new Test(false);Thread t1 = new Thread(test1);Thread t2 = new Thread(test2);t1.start();t2.start();}}

其中MyLockA和MyLockB指代的是不同的Object对象，当然也可以是其他的类的对象，因为此处的对象锁可以是任意对象

但若写的是同步函数的形式，则锁对象是固定的this，我们还知道this永远都是指向当前对象的（也就是谁调用这个函数，this就指代的谁。）所以当采用继承Thread类来实现多线程时并不能实现同步的效果，因为不同的线程是不同的Thread子类对象，this指代的也不一样，从而锁也不一样。下面给出程序证明观点：

class Bank {private int sum;public void add (int num) {sum += num;System.out.println(Thread.currentThread().getName()+"...sum=" + sum);}}class Customer extends Thread{ private Bank b = new Bank();@Overridepublic void run() {this.storage();}public synchronized void storage () {for (int i = 0; i < 5; i++) {if(i == 3)try {Thread.sleep(2000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}b.add(100);}}}public class BankAndCustomer {public static void main(String[] args) {Customer c1 = new Customer();Customer c2 = new Customer();c1.start();c2.start();}}

以上代码的输出结果是（当然多线程的输出结果不唯一）：

其中sleep方法是不释放锁对象的，但当其中一个线程休眠之后其他线程立即得到了cpu执行权，来执行storage方法，这足以证明上述观点。

但用通过实现Runnable接口的形式来实现多线程则上述问题可以避免，因为实现线程时我们传递的是Runnable接口的子类对象，两个线程都是子类对象调用的run方法（建议查看API中的Thread类的run方法，一探究竟。），故this所指代的对象是一致的，故当一个线程输出三次循环后，休眠两秒并未被打断，而是苏醒后继续执行。下面给出代码：

class Bank {private int sum;public void add (int num) {sum += num;System.out.println(Thread.currentThread().getName()+"...sum=" + sum);}}class Customer implements Runnable{ private Bank b = new Bank();@Overridepublic void run() {this.storage();}public synchronized void storage () {for (int i = 0; i < 5; i++) {if(i == 3)try {Thread.sleep(2000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}b.add(100);}}}public class BankAndCustomer {public static void main(String[] args) {Customer c = new Customer();Thread t1 = new Thread(c);Thread t2 = new Thread(c);t1.start();t2.start();}}

同时我们需要说明的是，当同步函数被标注为静态函数是他的默认锁对象就不是this了，因为静态中是没有this的。由类名直接调用，而不需要对象。锁对象变为类名.class，上例中若声明为public static synchronized void storage ()锁对象就是Customer.class