Java创建多线程1.继承Thread并重写Run方法2.实现Runnable接口并重写Run方法 ； 使用synchronized同步方法、同步代码块实例展示

理论依据：http://t.csdn.cn/sYEp1

测试类

public class Test {
    public static void main(String[] args) {
        //创建线程对象，调用start()方法启动线程
        MyThread myThread1=new MyThread();
        //创建线程类对象并将自定义类对象作为参数传进去
        Mythreads mythreads=new Mythreads();
        myThread1.setName("线程1");
        Thread myThread2=new Thread(mythreads);
        myThread2.setName("线程2");
        Thread myThread3=new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 100; i < 200; i++) {
                    System.out.println(i+Thread.currentThread().getName());
                }
            }
        });
        myThread3.setName("线程3");
        //线程常用方法 1.更改线程优先级1-10，默认为5
        myThread1.setPriority(6);
        myThread2.setPriority(6);
        myThread1.start();
        myThread2.start();
        myThread3.start();
        //使用getState()接口获取线程的状态
        System.out.println(myThread1.getState());
        try {
            System.out.println("睡眠开始");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //关闭线程
        myThread3.interrupt();
        try {
            //进入就绪状态，等待其他线程结束启动线程
            myThread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(myThread3.isInterrupted());

        SynchronizedMyThread synchronizedMyThread=new SynchronizedMyThread();
        SynchronizedMyThreads synchronizedMyThreads=new SynchronizedMyThreads();
        new Thread(synchronizedMyThread,"A").start();
        new Thread(synchronizedMyThread,"B").start();
        new Thread(synchronizedMyThread,"C").start();
        new Thread(synchronizedMyThreads,"B").start();
        new Thread(synchronizedMyThreads,"C").start();
    }
}

运行结果

RUNNABLE
睡眠开始
0线程1
1线程1
2线程1
3线程1
4线程1
5线程1
6线程1
7线程1
8线程1
9线程1
10线程1
11线程1
12线程1
13线程1
14线程1
15线程1
16线程1
17线程1
18线程1
19线程1
20线程1
21线程1
22线程1
23线程1
24线程1
25线程1
26线程1
27线程1
28线程1
29线程1
30线程1
31线程1
100线程3
32线程1
0线程2
33线程1
34线程1
35线程1
36线程1
37线程1
38线程1
39线程1
40线程1
41线程1
101线程3
102线程3
103线程3
104线程3
42线程1
43线程1
44线程1
1线程2
45线程1
105线程3
106线程3
107线程3
46线程1
2线程2
47线程1
48线程1
108线程3
49线程1
3线程2
109线程3
4线程2
110线程3
5线程2
6线程2
7线程2
111线程3
8线程2
9线程2
10线程2
112线程3
11线程2
113线程3
12线程2
114线程3
13线程2
115线程3
116线程3
117线程3
118线程3
119线程3
120线程3
121线程3
122线程3
123线程3
124线程3
14线程2
15线程2
16线程2
17线程2
18线程2
19线程2
20线程2
21线程2
22线程2
23线程2
24线程2
25线程2
125线程3
126线程3
127线程3
128线程3
129线程3
130线程3
131线程3
132线程3
133线程3
134线程3
135线程3
136线程3
137线程3
138线程3
139线程3
140线程3
141线程3
142线程3
143线程3
144线程3
145线程3
146线程3
147线程3
26线程2
148线程3
27线程2
149线程3
28线程2
150线程3
29线程2
151线程3
30线程2
31线程2
152线程3
32线程2
153线程3
154线程3
155线程3
33线程2
156线程3
157线程3
158线程3
159线程3
160线程3
34线程2
161线程3
162线程3
163线程3
164线程3
35线程2
165线程3
36线程2
166线程3
37线程2
167线程3
38线程2
39线程2
40线程2
41线程2
42线程2
168线程3
169线程3
170线程3
171线程3
43线程2
172线程3
44线程2
173线程3
45线程2
46线程2
47线程2
174线程3
48线程2
49线程2
175线程3
50线程2
51线程2
52线程2
53线程2
54线程2
55线程2
56线程2
57线程2
58线程2
59线程2
60线程2
61线程2
62线程2
63线程2
176线程3
177线程3
178线程3
179线程3
180线程3
181线程3
182线程3
183线程3
184线程3
185线程3
186线程3
187线程3
188线程3
189线程3
190线程3
191线程3
192线程3
193线程3
194线程3
195线程3
196线程3
197线程3
198线程3
199线程3
64线程2
65线程2
66线程2
67线程2
68线程2
69线程2
70线程2
71线程2
72线程2
73线程2
74线程2
75线程2
76线程2
77线程2
78线程2
79线程2
80线程2
81线程2
82线程2
83线程2
84线程2
85线程2
86线程2
87线程2
88线程2
89线程2
线程睡眠
准备礼让
50线程1
90线程2
51线程1
52线程1
53线程1
54线程1
55线程1
56线程1
57线程1
58线程1
59线程1
60线程1
61线程1
62线程1
63线程1
64线程1
65线程1
66线程1
67线程1
68线程1
69线程1
70线程1
71线程1
72线程1
73线程1
74线程1
75线程1
76线程1
77线程1
78线程1
79线程1
80线程1
81线程1
82线程1
83线程1
84线程1
85线程1
86线程1
87线程1
88线程1
89线程1
90线程1
91线程1
92线程1
93线程1
94线程1
95线程1
96线程1
97线程1
98线程1
99线程1
91线程2
92线程2
93线程2
94线程2
95线程2
96线程2
97线程2
98线程2
99线程2
线程睡眠
false
A10
A9
A8
A7
A6
A5
A4
A3
A2
A1
B开始过桥！耗时10s
B过桥成功！
C开始过桥！耗时10s
C过桥成功！

Process finished with exit code 0

//定义MyThread类继承Thread类

//定义MyThread类继承Thread类
public class MyThread extends Thread{
//重写run()方法，编写线程执行体
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i + Thread.currentThread().getName() );
            if((i+1)%50==0){
                try {
                    //线程常用方法 2.在指定的毫秒数让线程休眠
                    Thread.sleep(10);
                    System.out.println("线程睡眠");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

//定义Mythreads类实现Runnable接口

//定义Mythreads类实现Runnable接口
public class Mythreads implements Runnable{
    //实现run()方法，编写线程执行体
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i+Thread.currentThread().getName());
            if (i==89){
                //暂停当前正在执行的线程对象，并执行其他线程，只是提供一种可能，但是不能保证一定会实现礼让
                Thread.yield();
                System.out.println("准备礼让");
            }
        }
    }

//锁住线程，保证同时只能有一个线程进行，防止数据出错

public class SynchronizedMyThread implements Runnable {
    private static int number = 10;
    //锁住线程，保证同时只能有一个线程进行，防止数据出错
    @Override
    public synchronized void run() {
        while (true) {
            //锁住线程，保证同时只能有一个线程进行，防止多线程同时进行，条件越界（number==-1）
            if (number <= 0) {
                break;
            }
            System.out.println(Thread.currentThread().getName() +number);
            number--;
        }
    }
}

//锁住线程，保证同时只能有一个线程进行

public class SynchronizedMyThreads implements Runnable {
    //锁住线程，保证同时只能有一个线程进行
    @Override
    public void run() {
        synchronized (this){
            //保证只有一个线程进行代码
            System.out.println(Thread.currentThread().getName()+"开始过桥！耗时10s");
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"过桥成功！");
        }
    }
}