这两篇文章写得真的好：

• Java多线程学习（吐血超详细总结）
• 深入理解Java并发之synchronized实现原理

---

---

两种实现方式：

• 继承Thread类
• 实现Runnable接口

---

继承Thread类

构造Thread实例   - public Thread()   - public Thread(String threadName) 创建名为 ThreadName 的线程对象

public class Test extends Thread
{private int count=10;public void run(){while(true){System.out.printlnl(count + "");if(--count==0){return;}}}public static void main(String[] args){new Test().start();}
}

• 实现线程的代码写在run方法中
• 调用start方法执行线程（调用run()方法）
• 主方法调用start方法前，Thread对象仅是一个实例，并不是线程

---

实现Runnable接口

实现Runnable接口语法： public class Thread Extends Object implements Runnable 构造方法： public Thread(Runnable target) public Thread(Runnable target, String name)   于是实现了将Runable实例与Thread实例相关联

使用Runnable接口启动新线程的步骤如下：

• 建立Runnable对象
• 使用参数为Runnable对象的构造方法创建Thread实例
• 调用start方法启动线程

Thread t = new Thread(new Runnable(){public void run(){while(..){...}}
t.start();

---

线程的生命周期

状态	说明
出生	start()调用之前都处于出生状态
就绪	调用start()后，就绪
运行	线程得到系统资源后，运行
等待	调用wait()，等待。调用notify()唤醒
休眠	调用sleep()后，休眠
阻塞	运行时发出输入、输出请求，阻塞
死亡	run()执行完毕后，死亡

• 使线程进入就绪状态
• sleep()
• wait()
• 等待输入、输出完成

---

• 使线程由就绪到运行
• notify()
• notifyAll() 唤醒所有等待状态线程
• interrupt()
• 休眠时间结束
• 输入、输出结束

---

线程的加入 join()

• 某线程使用join()方法加入另一线程时，另一线程会等待该线程执行完毕再执行。

Thread threadA = new Thread(new Runnable(){int count=0;public void run(){while(true){...threadB.join();}}}

---

线程让步

• Thread.yield()方法。暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。

---

线程的优先级 setPriority()

• 新线程继承父类优先级
• 优先级1-10

常数	优先级
Thread.MAX_PRIORITY	10
Thread.MIN_PRIORITY	1
Thread.NORM_PRIORITY	5

Thread thread_a = new Thread();
setPriority("thread_a", 5, thread_a);
thread_a.setPriority(5);
thread_a.setName(name);	//设置线程名字

---

线程同步

• 线程同步机制——解决资源访问冲突

线程同步机制

---

同步块 synchronized

• 把共享资源放在同步块（临界区）

synchronized(Object){
}

---

同步方法 synchronized

• 必须将每个能访问共享资源的方法修饰为synchronized

synchronized void func(){
}

public synchronized void doit(){if(num>0){try{Thread.sleep(10);}catch(Exception e){e.printStackTrace();}System.out.println("tickets" + --num);}
}
public void run(){while(true){doit();}
}

---

synchronized 具体应用

• 1. 作用于实例方法

public class Test implements Runnable{//共享资源/临界资源static int i=0;// synchronized 修饰实例方法public synchronized void increase(){i++;}@Overridepublic void run() {for(int j=0;j<1000;j++){increase();}}public static void main(String[] args) throws InterruptedException {Test instance=new Test();Thread t1=new Thread(instance);Thread t2=new Thread(instance);t1.start();t2.start();t1.join();t2.join();System.out.println(i);}
}

输出：
>>> 2000

• 如果实例不同，那就是不同的实例方法，谁也锁不着谁了。

public static void main(String[] args) throws InterruptedException {Thread t1=new Thread(new Test());Thread t2=new Thread(new Test());t1.start();t2.start();t1.join();t2.join();System.out.println(i);
}

---

• 2. 作用于静态方法

public class Test implements Runnable{static int i=0;// 作用于静态方法,锁是当前class对象public static synchronized void increase(){i++;}// 非静态,访问时锁不一样(实例对象不一样) 不会 发生互斥public synchronized void increase4Obj(){i++;}@Overridepublic void run() {for(int j=0;j<1000000;j++){increase();}}public static void main(String[] args) throws InterruptedException {//new新实例Thread t1=new Thread(new Test());//new另一个实例Thread t2=new Thread(new Test());//启动线程t1.start();t2.start();t1.join();t2.join();System.out.println(i);}
}

• 作用于静态方法，就不用但是实例对象不一样的问题了。

---

• 3. 同步代码块

public class Test implements Runnable{static Test instance=new Test();static int i=0;@Overridepublic void run() {//...do something...//锁对象为instancesynchronized(instance){for(int j=0;j<1000000;j++){i++;}}}public static void main(String[] args) throws InterruptedException {Thread t1=new Thread(instance);Thread t2=new Thread(instance);t1.start();t2.start();t1.join();t2.join();System.out.println(i);}
}

---

• 实例对象锁【同上】

public static void run(){synchronized(this){for(...){...}}
}

• class对象锁

public static void run(){synchronized(Test.class){for(...){...}}
}