1 package com.mmzs.primary;
 2 
 3 public class test2 {
 4 
 5     public static void main(String[] args) {
 6         
 7         Thread1 th1=new Thread1("线程A");  
 8         Thread1 th2=th1;  
 9         th1.start();  
10         th2.start();  
11 
12     }
13 
14 }

Exception in thread "main" 线程A运行  :  0
java.lang.IllegalThreadStateException
线程A运行  :  1
线程A运行  :  2
线程A运行  :  3
线程A运行  :  4
    at java.lang.Thread.start(Unknown Source)
    at com.mmzs.primary.test2.main(test2.java:10)

package com.mmzs.primary;

class Thread2 implements Runnable{  
    private String name;  
  
    public Thread2(String name) {  
        this.name=name;  
    }  
  
    @Override  
    public void run() {  
          for (int i = 0; i < 5; i++) {  
                System.out.println(name + "运行  :  " + i);  
                try {  
                    Thread.sleep((int) Math.random() * 10);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
          
    }  
      
}  
public class test3 {  
  
    public static void main(String[] args) { 
        //注意此处和继承Thread的启动方式有些许区别；
        //此处仍然是new了两个线程
        new Thread(new Thread2("线程C")).start();  
        new Thread(new Thread2("线程D")).start();  
    }  
  
}  

1     private static void doSomething(long executeTime) {
2         try {
3             Thread.sleep(executeTime);
4         } catch (InterruptedException e) {
5             e.printStackTrace();
6         }
7     }

1 //锁都加在调用该方法的当前对象上面
2     public synchronized void synchronizedMethodOnThis(long executeTime) {
3         System.out.println(Thread.currentThread().getName() + " -> start synchronizedMethodOnThis");
4         doSomething(executeTime);
5         System.out.println(Thread.currentThread().getName() + " -> end synchronizedMethodOnThis");
6     }

1     public void synchronizedBlockOnThis(long executeTime) {
2         synchronized (this) {//（1）this指的是什么呢？它指的就是调用这个方法的对象
3             System.out.println(Thread.currentThread().getName() + " -> start synchronizedBlockOnThis");
4             doSomething(executeTime);
5             System.out.println(Thread.currentThread().getName() + " -> end synchronizedBlockOnThis");
6         }
7     }

1     private Object lock = new Object();
2     public void synchronizedBlockOnObject(long executeTime) {
3         synchronized (lock) {
4             System.out.println(Thread.currentThread().getName() + " -> start synchronizedBlockOnObject");
5             doSomething(executeTime);
6             System.out.println(Thread.currentThread().getName() + " -> end synchronizedBlockOnObject");
7         }
8     }

1 class FooThread implements Runnable {  
2        private byte[] lock = new byte[0];  // 特殊的instance变量  
3     Public void methodA() {  
4        synchronized(lock) { 
5            ……
6        }
7     }  
8 }  

 1 package com.mmz.Synchronized;
 2 
 3 public class SynchronizedTest {
 4 
 5     //都加在 MyClass.class 对象上面,即此处的SynchronizedTest
 6     public static synchronized void synchronizedMethodOnClass(long executeTime) {
 7         System.out.println(Thread.currentThread().getName() + " -> start synchronizedMethodOnClass");
 8         doSomething(executeTime);
 9         System.out.println(Thread.currentThread().getName() + " -> end synchronizedMethodOnClass");
10     }
11     
12     public void synchronizedBlockOnClass(long executeTime) {
13         synchronized (SynchronizedTest.class) {
14             System.out.println(Thread.currentThread().getName() + " -> start synchronizedBlockOnClass");
15             doSomething(executeTime);
16             System.out.println(Thread.currentThread().getName() + " -> end synchronizedBlockOnClass");
17         }
18     }
19    
20 } 

 1 package com.mmzs.primary;
 2 
 3 public class MyThread extends Thread {   
 4     private String name;   
 5     public MyThread(String name) {   
 6         this.name = name;   
 7     }   
 8     public void run() {   
 9         System.out.println("hello " + name);   
10     }   
11     public static void main(String[] args) {   
12         Thread thread = new MyThread("world");   
13         thread.start();   
14     }   
15 }   

 1 public class MyThread2 implements Runnable{   
 2     private String name;   
 3     public void setName(String name) {   
 4         this.name = name;   
 5     }   
 6     public void run() {   
 7         System.out.println("hello " + name);   
 8     }   
 9     public static void main(String[] args) {   
10         MyThread2 myThread = new MyThread2();   
11         myThread.setName("world");   
12         Thread thread = new Thread(myThread);   
13         thread.start();   
14     }   
15 }  

 1 package com.mmzs.primary;
 2 
 3 import java.util.ArrayList;
 4 
 5 class Data {   
 6     public int value = 0;   
 7 }   
 8 class Work {   
 9     public void process(Data data, ArrayList<Integer> numbers) {
10         for (int n : numbers) {   
11             data.value += n;  
12         }   
13     }
14 }   
15 
16 public class MyThread3 extends Thread {   
17     private Work work;  
18     ArrayList<Integer> list = new ArrayList<Integer>();
19     public MyThread3(Work work) {   
20         this.work = work;   
21     }   
22     public void run() {   
23     java.util.Random random = new java.util.Random();   
24     Data data = new Data();   
25     int n1 = random.nextInt(1000);   
26     int n2 = random.nextInt(2000);   
27     int n3 = random.nextInt(3000); 
28     list.add(n1);
29     list.add(n2);
30     list.add(n3);
31     work.process(data,list); // 使用回调函数   
32     System.out.println(String.valueOf(n1) + "+" + String.valueOf(n2) + "+"                   
33         + String.valueOf(n3) + "=" + data.value);   
34     }   
35     public static void main(String[] args) {   
36         Thread thread = new MyThread3(new Work());   
37         thread.start();   
38     }   
39 }