java同步与多线程浅析

2七、多线程 同步的原理

　一． 实现多线程　　1. 虚假的多线程



　　例1：

public class TestThread

{

　int i=0, j=0;

　public void go(int flag)

　{

　　while(true)

　　{

　　　try{ Thread.sleep(100);

　　}

　　catch(InterruptedException e)

　　{

　　　System.out.println("Interrupted");

　　}

　　if(flag==0) i++;

　　System.out.println("i=" + i);

　　}

　　else

　　{

　　　j++;

　　　System.out.println("j=" + j);

　　}

　}

}

public static void main(String[] args)

{

　new TestThread().go(0);

　new TestThread().go(1);

}

}

　　上面程序的运行结果为：



i=1 i=2 i=3 。。。



　　结果将一直打印出I的值。咱们的意图是当在while循环中调用sleep()时，另外一个线程就将起动，打印出j的值，但结果却并非这样。关于sleep()为何不会出现咱们预想的结果，在下面将讲到。

探讨Java多线程及其同步的实现

 
 
 
 
 
 
 
 
 
 
 
 

　　2. 实现多线程



　　经过继承class　Thread或实现Runnable接口，咱们能够实现多线程



　　2.1 经过继承class　Thread实现多线程



　　class　Thread中有两个最重要的函数run()和start()。



　　1) run()函数必须进行覆写，把要在多个线程中并行处理的代码放到这个函数中。



　　2) 虽然run()函数实现了多个线程的并行处理，但咱们不能直接调用run()函数，而是经过调用start()函数来调用run()函数。在调用start()的时候，start()函数会首先进行与多线程相关的初始化（这也是为何不能直接调用run()函数的缘由），而后再调用run()函数。



　　例2：

public class TestThread extends Thread

{

　private static int threadCount = 0;

　private int threadNum = ++threadCount;

　private int i = 5;

　public void run()

　{

　　while(true)

　　{

　　　try

　　　{

　　　　Thread.sleep(100);　

　　　}

　　　catch(InterruptedException e)

　　　{

　　　　System.out.println("Interrupted");

　　　}

　　　System.out.println("Thread " + threadNum +
" = " + i);

　　　if(--i==0) return;

　　}

　}



　public static void main(String[] args)

　{

　　for(int i=0; i<5; i++)

　　　new TestThread().start();

　}

}

　　运行结果为：



Thread 1 = 5

Thread 2 = 5

Thread 3 = 5

Thread 4 = 5

Thread 5 = 5

Thread 1 = 4

Thread 2 = 4

Thread 3 = 4

Thread 4 = 4

Thread 1 = 3

Thread 2 = 3

Thread 5 = 4

Thread 3 = 3

Thread 4 = 3

Thread 1 = 2

Thread 2 = 2

Thread 5 = 3

Thread 3 = 2

Thread 4 = 2

Thread 1 = 1

Thread 2 = 1

Thread 5 = 2

Thread 3 = 1

Thread 4 = 1

Thread 5 = 1



　　从结果可见，例2能实现多线程的并行处理。



　　**：在上面的例子中，咱们只用new产生Thread对象，并无用reference来记录所产生的Thread对象。根据垃圾回收机制，当一个对象没有被reference引用时，它将被回收。可是垃圾回收机制对Thread对象“不成立”。由于每个Thread都会进行注册动做，因此即便咱们在产生Thread对象时没有指定一个reference指向这个对象，实际上也会在某个地方有个指向该对象的reference，因此垃圾回收器没法回收它们。

　　3) 经过Thread的子类产生的线程对象是不一样对象的线程

class TestSynchronized extends Thread

{

　public TestSynchronized(String name)

　{

　　super(name);

　}

　public synchronized static void prt()

　{

　　for(int i=10; i<20; i++)

　　{

　　　System.out.println(Thread.currentThread().getName()
+ " : " + i);

　　　try

　　　{

　　　　Thread.sleep(100);

　　　}

　　　catch(InterruptedException e)

　　　{

　　　　System.out.println("Interrupted");

　　　}

　　}

　}



　public synchronized void run()

　{

　　for(int i=0; i<3; i++)

　　{

　　　System.out.println(Thread.currentThread().getName()
+ " : " + i);

　　　try

　　　{

　　　　Thread.sleep(100);

　　　}

　　　catch(InterruptedException e)

　　　{

　　　　System.out.println("Interrupted");

　　　}

　　}

　}

}



　public class TestThread

　{

　　public static void main(String[] args)

　　{

　　　TestSynchronized t1 = new TestSynchronized("t1");

　　　TestSynchronized t2 = new
TestSynchronized("t2");

　　　t1.start();

　　　t1.start();　//（1）

　　　//t2.start();　（2） }}

　　运行结果为：



t1 : 0

t1 : 1

t1 : 2

t1 : 0

t1 : 1

t1 : 2



　　因为是同一个对象启动的不一样线程，因此run()函数实现了synchronized。若是去掉（2）的注释，把代码（1）注释掉，结果将变为：



t1 : 0

t2 : 0

t1 : 1

t2 : 1

t1 : 2

t2 : 2



　　因为t1和t2是两个对象，因此它们所启动的线程可同时访问run()函数。

　　2.2 经过实现Runnable接口实现多线程



　　若是有一个类，它已继承了某个类，又想实现多线程，那就能够经过实现Runnable接口来实现。



　　1) Runnable接口只有一个run()函数。



　　2) 把一个实现了Runnable接口的对象做为参数产生一个Thread对象，再调用Thread对象的start()函数就可执行并行操做。若是在产生一个Thread对象时以一个Runnable接口的实现类的对象做为参数，那么在调用start()函数时，start()会调用Runnable接口的实现类中的run()函数。



　　例3.1：

public class TestThread implements Runnable

{

　private static int threadCount = 0;

　private int threadNum = ++threadCount;

　private int i = 5;

　public void run()

　{

　　while(true)

　　{

　　　try

　　　{

　　　　Thread.sleep(100);

　　　}

　　　catch(InterruptedException e)

　　　{

　　　　System.out.println("Interrupted");

　　　}

　　　System.out.println("Thread " + threadNum +
" = " + i);

　　　if(--i==0) return;

　　}

　}



　public static void main(String[] args)

　{

　　for(int i=0; i<5; i++) new Thread(new
TestThread()).start();　//（1）

　}

}

　　运行结果为：



Thread 1 = 5

Thread 2 = 5

Thread 3 = 5

Thread 4 = 5

Thread 5 = 5

Thread 1 = 4

Thread 2 = 4

Thread 3 = 4

Thread 4 = 4

Thread 4 = 3

Thread 5 = 4

Thread 1 = 3

Thread 2 = 3

Thread 3 = 3

Thread 4 = 2

Thread 5 = 3

Thread 1 = 2

Thread 2 = 2

Thread 3 = 2

Thread 4 = 1

Thread 5 = 2

Thread 1 = 1

Thread 2 = 1

Thread 3 = 1

Thread 5 = 1



　　例3是对例2的修改，它经过实现Runnable接口来实现并行处理。代码（1）处可见，要调用TestThread中的并行操做部分，要把一个TestThread对象做为参数来产生Thread对象，再调用Thread对象的start()函数。



　　3) 同一个实现了Runnable接口的对象做为参数产生的全部Thread对象是同一对象下的线程。



　　例3.2：

package mypackage1;

public class TestThread implements Runnable

{

　public synchronized void run()

　{

　　for(int i=0; i<5; i++)

　　{

　　　System.out.println(Thread.currentThread().getName()
+ " : " + i);

　　　try

　　　{

　　　　Thread.sleep(100);

　　　}

　　　catch(InterruptedException e)

　　　{

　　　　System.out.println("Interrupted");

　　　}

　　}

　}



　public static void main(String[] args)

　{

　　TestThread testThread = new TestThread();

　　for(int i=0; i<5; i++)

　　//new Thread(testThread, "t" + i).start();　（1）

　　new Thread(new TestThread(), "t" +
i).start();　（2） }}

　　运行结果为：



t0 : 0

t1 : 0

t2 : 0

t3 : 0

t4 : 0

t0 : 1

t1 : 1

t2 : 1

t3 : 1

t4 : 1

t0 : 2

t1 : 2

t2 : 2

t3 : 2

t4 : 2

t0 : 3

t1 : 3

t2 : 3

t3 : 3

t4 : 3

t0 : 4

t1 : 4

t2 : 4

t3 : 4

t4 : 4



　　因为代码（2）每次都是用一个新的TestThread对象来产生Thread对象的，因此产生出来的Thread对象是不一样对象的线程，因此全部Thread对象均可同时访问run()函数。若是注释掉代码（2），并去掉代码（1）的注释，结果为：



t0 : 0

t0 : 1

t0 : 2

t0 : 3

t0 : 4

t1 : 0

t1 : 1

t1 : 2

t1 : 3

t1 : 4

t2 : 0

t2 : 1

t2 : 2

t2 : 3

t2 : 4

t3 : 0

t3 : 1

t3 : 2

t3 : 3

t3 : 4

t4 : 0

t4 : 1

t4 : 2

t4 : 3

t4 : 4



　　因为代码（1）中每次都是用同一个TestThread对象来产生Thread对象的，因此产生出来的Thread对象是同一个对象的线程，因此实现run()函数的同步。

　　二． 共享资源的同步

　　1. 同步的必要性



　　例4：

class Seq

{

　private static int number = 0;

　private static Seq seq = new Seq();

　private Seq() {}

　public static Seq getInstance()

　{

　　return seq;

　}

　public int get()

　{

　　number++; 　

　　//（a）


　　return number;　

　　//（b）


　}

}



public class TestThread

{

　public static void main(String[] args)

　{

　　Seq.getInstance().get();　

　　//（1）

　　Seq.getInstance().get();　

　　//（2）


　}

}

　　上面是一个取得序列号的单例模式的例子，但调用get()时，可能会产生两个相同的序列号：



　　当代码（1）和（2）都试图调用get()取得一个惟一的序列。当代码（1）执行完代码（a），正要执行代码（b）时，它被中断了并开始执行代码（2）。一旦当代码（2）执行完（a）而代码（1）还未执行代码（b），那么代码（1）和代码（2）就将获得相同的值。

　　2. 经过synchronized实现资源同步



　　2.1 锁标志



　　2.1.1 每一个对象都有一个标志锁。当对象的一个线程访问了对象的某个synchronized数据（包括函数）时，这个对象就将被“上锁”，因此被声明为synchronized的数据（包括函数）都不能被调用（由于当前线程取走了对象的“锁标志”）。只有当前线程访问完它要访问的synchronized数据，释放“锁标志”后，同一个对象的其它线程才能访问synchronized数据。



　　2.1.2 每一个class也有一个“锁标志”。对于synchronized
static数据（包括函数）能够在整个class下进行锁定，避免static数据的同时访问。



　　例5：

class Seq

{

　private static int number = 0;

　private static Seq seq = new Seq();

　private Seq() {}

　public static Seq getInstance(){ return seq; }

　public synchronized int get()

　{

　　//（1）


　　number++;

　　return number;

　}

}

　　例5在例4的基础上，把get()函数声明为synchronized，那么在同一个对象中，就只能有一个线程调用get()函数，因此每一个线程取得的number值就是惟一的了。



　　例6：

class Seq

{

　private static int number = 0;

　private static Seq seq = null;

　private Seq() {}

　synchronized public static Seq getInstance()

　{

　　//（1）


　　if(seq==null) seq = new Seq();

　　return seq;

　}

　public synchronized int get()

　{

　　number++;

　　return number;

　}

}

　　例6把getInstance()函数声明为synchronized，那样就保证经过getInstance()获得的是同一个seq对象。



　　2.2 non-static的synchronized数据只能在同一个对象的纯种实现同步访问，不一样对象的线程仍可同时访问。



　　例7：

class TestSynchronized implements Runnable

{

　public synchronized void run()

　{

　　//（1）

　　for(int i=0; i<10; i++)

　　{

　　　System.out.println(Thread.currentThread().getName()
+ " : " + i);

　　　/*（2）*/

　　　try

　　　{

　　　　Thread.sleep(100);

　　　}

　　　catch(InterruptedException e)

　　　{

　　　　System.out.println("Interrupted");

　　　}

　　}

　}

}



public class TestThread

{

　public static void main(String[] args)

　{

　　TestSynchronized r1 = new TestSynchronized();

　　TestSynchronized r2 = new TestSynchronized();

　　Thread t1 = new Thread(r1, "t1");

　　Thread t2 = new Thread(r2, "t2");　//(3) //

　　Thread t2 = new Thread(r1, "t2");　（4）

　　t1.start();

　　t2.start();

　}

}

　　运行结果为：



t1 : 0

t2 : 0

t1 : 1

t2 : 1

t1 : 2

t2 : 2

t1 : 3

t2 : 3

t1 : 4

t2 : 4

t1 : 5

t2 : 5

t1 : 6

t2 : 6

t1 : 7

t2 : 7

t1 : 8

t2 : 8

t1 : 9

t2 : 9



　　虽然咱们在代码（1）中把run()函数声明为synchronized，但因为t1、t2是两个对象（r1、r2）的线程，而run()函数是non-static的synchronized数据，因此仍可被同时访问（代码（2）中的sleep()函数因为在暂停时不会释放“标志锁”，由于线程中的循环很难被中断去执行另外一个线程，因此代码（2）只是为了显示结果）。



　　若是把例7中的代码（3）注释掉，并去年代码（4）的注释，运行结果将为：



t1 : 0

t1 : 1

t1 : 2

t1 : 3

t1 : 4

t1 : 5

t1 : 6

t1 : 7

t1 : 8

t1 : 9

t2 : 0

t2 : 1

t2 : 2

t2 : 3

t2 : 4

t2 : 5

t2 : 6

t2 : 7

t2 : 8

t2 : 9



　　修改后的t1、t2是同一个对象（r1）的线程，因此只有当一个线程（t1或t2中的一个）执行run()函数，另外一个线程才能执行。

　　2.3 对象的“锁标志”和class的“锁标志”是相互独立的。

例8：

class TestSynchronized extends Thread

{

　public TestSynchronized(String name)

　{

　　super(name);

　}



　public synchronized static void prt()

　{

　　for(int i=10; i<20; i++)

　　{

　　　System.out.println(Thread.currentThread().getName()
+ " : " + i);

　　　try

　　　{

　　　　Thread.sleep(100);

　　　}

　　　catch(InterruptedException e)

　　　{

　　　　System.out.println("Interrupted");

　　　}

　　}

　}



　public synchronized void run()

　{

　　for(int i=0; i<10; i++)

　　{

　　　System.out.println(Thread.currentThread().getName()
+ " : " + i);

　　　try

　　　{

　　　　Thread.sleep(100);

　　　}

　　　catch(InterruptedException e)

　　　{

　　　　System.out.println("Interrupted");

　　　}

　　}

　}

}



public class TestThread

{

　public static void main(String[] args)

　{

　　TestSynchronized t1 = new
TestSynchronized("t1");

　　TestSynchronized t2 = new
TestSynchronized("t2");

　　t1.start();

　　t1.prt();　//（1）

　　t2.prt();　//（2）

　}

}

　　运行结果为：



main : 10

t1 : 0

main : 11

t1 : 1

main : 12

t1 : 2

main : 13

t1 : 3

main : 14

t1 : 4

main : 15

t1 : 5

main : 16

t1 : 6

main : 17

t1 : 7

main : 18

t1 : 8

main : 19

t1 : 9

main : 10

main : 11

main : 12

main : 13

main : 14

main : 15

main : 16

main : 17

main : 18

main : 19

　　在代码（1）中，虽然是经过对象t1来调用prt()函数的，但因为prt()是静态的，因此调用它时不用通过任何对象，它所属的线程为main线程。



　　因为调用run()函数取走的是对象锁，而调用prt()函数取走的是class锁，因此同一个线程t1（由上面可知其实是不一样线程）调用run()函数且还没完成run()函数时，它就能调用prt()函数。但prt()函数只能被一个线程调用，如代码（1）和代码（2），即便是两个不一样的对象也不能同时调用prt()。

　　3. 同步的优化



　　1) synchronized　block



　　语法为：synchronized(reference){ do this }



　　reference用来指定“以某个对象的锁标志”对“大括号内的代码”实施同步控制。



　　例9：

class TestSynchronized implements Runnable

{

　static int j = 0;

　public synchronized void run()

　{

　　for(int i=0; i<5; i++)

　　{

　　　//（1）

　　　System.out.println(Thread.currentThread().getName()
+ " : " + j++);

　　　try

　　　{

　　　　Thread.sleep(100);

　　　}

　　　catch(InterruptedException e)

　　　{

　　　　System.out.println("Interrupted");

　　　}

　　}

　}

}



public class TestThread

{

　public static void main(String[] args)

　{

　　TestSynchronized r1 = new TestSynchronized();

　　TestSynchronized r2 = new TestSynchronized();

　　Thread t1 = new Thread(r1, "t1");

　　Thread t2 = new Thread(r1, "t2");

　　t1.start();

　　t2.start();

　}

}

　　运行结果为：



t1 : 0

t1 : 1

t1 : 2

t1 : 3

t1 : 4

t2 : 5

t2 : 6

t2 : 7

t2 : 8

t2 : 9



　　上面的代码的run()函数实现了同步，使每次打印出来的j老是不相同的。但实际上在整个run()函数中，咱们只关心j的同步，而其他代码同步与否咱们是不关心的，因此能够对它进行如下修改：

class TestSynchronized implements Runnable

{

　static int j = 0;

　public void run()

　{

　　for(int i=0; i<5; i++)

　　{

　　　//（1）

　　　synchronized(this)

　　　{

　　　　System.out.println(Thread.currentThread().getName()
+ " : " + j++);

　　　}

　　　try

　　　{

　　　　Thread.sleep(100);

　　　}

　　　catch(InterruptedException e)

　　　{

　　　　System.out.println("Interrupted");

　　　}

　　}

　}

}



public class TestThread

{

　public static void main(String[] args)

　{

　　TestSynchronized r1 = new TestSynchronized();

　　TestSynchronized r2 = new TestSynchronized();

　　Thread t1 = new Thread(r1, "t1");

　　Thread t2 = new Thread(r1, "t2");

　　t1.start();

　　t2.start();

　}

}

　　运行结果为：



t1 : 0

t2 : 1

t1 : 2

t2 : 3

t1 : 4

t2 : 5

t1 : 6

t2 : 7

t1 : 8

t2 : 9



　　因为进行同步的范围缩小了，因此程序的效率将提升。同时，代码（1）指出，当对大括号内的println()语句进行同步控制时，会取走当前对象的“锁标志”，即对当前对象“上锁”，不让当前对象下的其它线程执行当前对象的其它synchronized数据。