一． 实现多线程

　　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()为什么不会出现我们预想的结果，在下面将讲到。
　　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数据。