线程技术第三篇：
线程的状态：
1. 创建状态： 当用new 操作符创建一个新的线程对象时，该线程就处于创建状态，系统不为它分配资源
2.可运行状态：当线程调用start 方法将为线程分配必须的系统资源，安排其运行，并调用线程体中的run方法，这样线程就处于可运行状态
3.不可运行状态：当调用了sleep（）方法，或者object 类中的wait（） 方法，线程输入输出阻塞
4.消亡状态：run 方法执行完后，就会自动消亡
线程优先级：
1.线程创建时，子继承父的线程优先级
2.可以通过线程方法 setPriority()设置优先级
3.优先级在1-10整数之间
多线程的同步：
情景：在所线程环境里，可能有多个线程试图同时访问一个有限的资源，所以我们必须对这种潜在的资源冲突进行预防，
解决方法就是：在线程使用一个资源时候，对其加锁，访问资源的第一个线程为其加上锁之后，其他线程不可以进行对其的访问，除非锁被解除
synchronized 关键字：（都是重点）
1.当synchronized 关键字修饰一个方法的时候，那么该方法就是同步方法；
2. java 每个对象都有一把锁（监视器），当访问某个对象的synchronized 的方法时，表示将该对象上锁，那么其他的线程就无法访问synchronized 方法了，直到之前那个线程执行方法完毕后或者抛出异常，那么该对象的锁就会释放掉；其他线程才能访问synchronized 方法
3.如果一个对象有多个synchronized 方法，在某一时刻某一线程已经进入某个synchronized 方法，那么在该方法没有执行完毕之前，其他线程都无法访问
这个对象的任何synchronized 方法；
4.在遇到synchronized static 修饰的方法时候，它的锁不是synchronized 方法所在的对象，而是是当前对象所对应的的class 对象；因为static 是基于类的；
Example:
执行以下代码，我们可以明显看出，执行结果是有顺序的，因为synchronized 是在对象上加锁，只有执行完一个synchronized 方法，才能执行下一个synchronized
/**
* this demo diaplay keywords synchronized is add lock in Object
* when Object has many synchronized method , and some Thread invoke some synchronized method,
* then other Thread refuse to call on any synchronized method ，only if some synchronized method
* invoke finish.
*
* @author iscys
*
*/
public class SynchronizedObjectLock { public static void main(String[] args) {
//设置唯一对象
Example example =new Example();
ImplRunnable run1=new ImplRunnable(example);
ImplRunnable2 run2=new ImplRunnable2(example);
Thread th1 =new Thread(run1);
Thread th2 =new Thread(run2);
th1.start();
th2.start();
} } class Example{ public synchronized void ex() {
for(int i=0;i<20;i++) {
System.out.println("ex method"+i);
}
} public synchronized void ex2() {
for(int i=0;i<20;i++) {
System.out.println("ex2 method"+i);
}
}
} //one instance of thread
class ImplRunnable implements Runnable{ private Example example;
//construct
public ImplRunnable(Example example){
this.example =example;
}
@Override
public void run() {
example.ex(); } }
//one instance of thread
class ImplRunnable2 implements Runnable{ private Example example;
//construct
public ImplRunnable2(Example example){
this.example =example;
}
@Override
public void run() {
example.ex2(); } }
在这个例子的基础上，我们将一个方法改为静态方法去运行：其实执行的结果是乱序的，因为被static 修饰的方法，属于类本身，它的锁对应的是class 对象
而未被static 修饰的，锁则是synchrionized 所在的对象；
public synchronized static void ex2() {
for(int i=0;i<20;i++) {
System.out.println("ex2 method"+i);
}
5.同步的第二种方式，使用同步代码块 ,线程执行会对Object 对象上锁，其他规则与synchronized 一致
private Object object =new Object();
synchronized（object）{
//body.....
}