Java语言写成的程序一定是先从主线程开始操作，所以必须在程序的某个位置启动新的线程，才能算是真正的多线程程序。start()方法是 Thread类的方法，调用start()方法，就会启动新的线程。请注意，被调用来启动线程的是start()方法，而非run()方法。调用 start()方法之后，Java执行处理系统会在背后启动新的线程。再由这个新的线程调用run()方法。调用start()方法，会有两个操作：

• 启动新的线程
• 调用run方法

线程的启动

利用Thread类的子类

1. public class PrintThread extends Thread {
2. private String msg;
3. public PrintThread(String msg) {
4. this.msg = msg;
5. }
6. public void run() {
7. for(int i = 0; i < 10000; i++) {
8. System.out.print(msg);
9. }
10. }
11. public static void main(String[] args {
12. new PrintThread("Good!").start();
13. new PrintThread("Nice!").start();
14. }
15. }

在main()方法里，先建立PrintThread类的实例后，调用该实例的 start()方法启动线程。建立“PrintThread类的实例”和“启动该实例所对应的线程”是两个完全不同的处理。即使已经建立了实例，仍然必须 等到调用start()方法才会启动线程。主线程在main()方法里启动两个线程，因为main()方法会立即结束，所以主线程也会立即结束，不过整个 程序还没有结束，一直要等到所有线程都已经结束，程序才会结束。不过这里不包括daemon thread。利用Runnable接口

Runnable接口是java.lang Package里的接口，声明方法如下：

1. public class PrintThread implements Runnable {
2. private String msg;
3. public PrintThread(String msg) {
4. this.msg = msg;
5. }
6. public void run() {
7. for(int i = 0; i < 10000; i++) {
8. System.out.print(msg);
9. }
10. }
11. public static void main(String[] args {
12. new Thread(new PrintThread("Good!")).start();
13. new Thread(new PrintThread("Nice!")).start();
14. }
15. }

不管是利用Thread类的子类还是利用Runnable接口的实现类来启动线程，都是通过Thread类的start()方法。

利用Thread类的sleep()方法即可暂时停在线程的执行操作。注意，sleep()方法是Thread类的静态方法。

synchronized方法

当
一个方法加上关键字synchronized声明之后，就可以让1个线程操作这个方法。这种线程称为synchronized方法，又称为同步方法。
synchronized实例方法就是使用this锁定去做线程的共享互斥。synchronized类方法是使用该类的类对象的锁定去做线程的共享互斥

所
有实例都有一个wait set，wait
set是一个在执行该实例的wait方法时、操作停止的线程的集合。一个执行wait()方法时，线程便会暂时停止操作，进入wait
set这个休息室。如欲执行wait()方法，线程需获取锁定。但是当线程进入wait
set时，已经释放了该实例的锁定。使用notify()方法时，可从wait
set里抓取一个线程。线程必须有调用实例的锁定，才能执行notify()方法，这跟调用wait()方法一样。使用notifyAll()方法时，会
将所有在wait

set里等待的线程全部拿出来。同样，线程必须获取调用实例的锁定，才能调用notifyAll()方法。注意，wait()、notify()、
notifyAll()方法都是Object类的方法。

1. public class Main {
2. public static void main(String[] args) {
3. System.out.println("Testing Gate, hit CTRC+C to exit.");
4. Gate gate = new Gate();
5. new UserThread(gate, "Alice", "Alaska").start();
6. new UserThread(gate, "Bobby", "Brazil").start();
7. new UserThread(gate, "Chris", "Canada").start();
8. }
9. }
10. public class Gate {
11. private int counter = 0;
12. private String name = "Nobody";
13. private String address = "Nowhere";
14. public void pass(String name, String address) {
15. this.counter++;
16. this.name = name;
17. this.address = address;
18. check();
19. }
20. public String toString() {
21. return "No. " + counter + " name: " + name + ", address: " + address;
22. }
23. private void check() {
24. if (name.charAt(0) != address.charAt(0)) {
25. System.out.println("******BROKEN*******" + toString());
26. }
27. }
28. public class UserThread extends Thread {
29. private final Gate gate;
30. private final String myname;
31. private final String myaddress;
32. public UserThread (Gate gate, String myname, String myaddress) {
33. this.gate = gate;
34. this.myname = myname;
35. this.myaddress =myaddress;
36. }
37. public void run() {
38. System.out.println(this.myname + "Begin");
39. while(true) {
40. gate.pass(this.myname,myaddress);
41. }
42. }
43. }
44. }

1. public class Gate {
2. private int counter = 0;
3. private String name = "Nobody";
4. private String address = "Nowhere";
5. public synchronized void pass(String name, String address) {
6. this.counter++;
7. this.name = name;
8. this.address = address;
9. check();
10. }
11. public synchronized String toString() {
12. return "No. " + counter + " name: " + name + ", address: " + address;
13. }
14. private void check() {
15. if (name.charAt(0) != address.charAt(0)) {
16. System.out.println("******BROKEN*******" + toString());
17. }
18. }
19. }

1. public final class Person {
2. private final String name;
3. private final String address;
4. public Person(String name, String address) {
5. this.name = name;
6. this.address = address;
7. }
8. public String getName() {
9. return this.name;
10. }
11. public String getAddress() {
12. return this.address;
13. }
14. public String toString() {
15. return "[ Person: name =" + name + ", address = " + address + " ]";
16. }
17. }
18. public class Main() {
19. public static void main(String[] args){
20. Person alice = new Person("Alice", "Alaska");
21. new PrintPersonThread(alice).start();
22. new PrintPersonThread(alice).start();
23. new PrintPersonThread(alice).start();
24. }
25. }
26. public class PrintPersonThread extends Thread {
27. private Person person;
28. public PrintPersonThread(Person persion) {
29. this.person = person;
30. }
31. public void run() {
32. while(true) {
33. System.out.println(Thread.currentThread().getName() + " prints " + person);
34. }
35. }
36. }