线程简介--单利模式饿汉式和懒汉式

1/创建线程：类继承Thread类复写Runnable的run()方法。start()作用：调用run方法、开启线程。只有调用Strat()方法才能开启线程。

2/线程的的状态：创建、运行、阻塞、死亡四种状态。注：线程的阻塞状态结束之后不一定会立刻执行，该线程需要取得CPU的执行权（意思：具备运行资格，但是没有执行权）。

3/j第二种创建线程的方法：定义类实现Runnable接口，复写Runnable接口的run()方法，创建Thread对象，并将实现Runnable类的对象作为创建Thread对象构造函数的参数。

4/实现Runnable接口可以实现资源共享。

5/停止线程的唯一方法是该线程的run()方法结束（stop()已经过时）。

6/当线处于程冻结状态时（wait(),sleep()，join()等状态时），可用线程调用interrupt()方法对冻结进行清除，此时抛出interruptException异常，然后继续执行。
//
public class Main {

/**
* @param args
*/
static int num=0;
public static void main(String[] args) {
RunnableTest runnable=new RunnableTest();
Thread thread1=new Thread(runnable);
Thread thread2=new Thread(runnable);
thread1.start();
thread2.start();
while (true) {
if(++num==60){//如果num的值为60时，flag为true，并终止循环
thread1.interrupt();//清除异常
thread2.interrupt();
//        		  runnable.setflag();//特殊情况,虽然改变了flag的值,但是并没终止线程循环
break;
}
System.out.println(Thread.currentThread().getName()+"......Main-->"+num);
}
}
}

//
public class RunnableTest implements Runnable {
boolean flag=true;
@Override
public   synchronized   void run() {

while (flag) {
try {

wait();//此时Thread1和Thread2分别处于阻状态塞，并放弃了cpu执行权

} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName()+"......exception");
flag=false;//改变flag值退出循环
}

System.out.println(Thread.currentThread().getName()+"......run");
}
}
public void setflag(){
flag=true;
}

}

7/线程死锁:一般出现在双重的同步程序同一把锁,并且不是,两个线程分别拥有的两把锁中不同的一把锁,而这两个线程分别等待对方释放锁

简单例子描述:
//主方法
main(){
//创建两个线程并启动两个线程
}

public class DemoLock implements Runnable{
Object obj=new Object();
run(){
.......

}
public synchronized  void show(){//锁是this
synchronized(obj){//锁是obj
.....
}
}
}

7/线程的单例模式

//单例模式设计

//恶汉式

class  Test
{
private final Static	Test test=new Test();
private Test(){}
public static Test getInstence(){
return test;
}
}

//懒汉式

class Test
{
private static Test test=null;
private Test(){}
public static Test getInstence(){
if(test==null){
synchronized (Test.class){
if(test=null){
test=new Test();
}
}
}
return test;
}

}
//懒汉式和饿汉式的区别:懒汉式延迟加载,但懒汉式在多线程并行访问时会出现安全问题,
//解决方法是使用同步函数,但是效率低一点(因为每个线程都要访问锁进行判断),解决方法是双重否定.