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();
@Override
public 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 block
e.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();
@Override
public 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 block
e.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