多线程待总结

多线程待总结线程的状态：1，创建状态、创建后，有了相应的内存空间和其他资源，但还处于不可运行状态。

2，就绪状态调用线程得start（）方法就可以启动线程。

当线程启动，就进入了就绪状态。

此时线程进入队列排队，等待cpu服务，表明具有了运行条件。

3，运行状态、当就绪状态的线程被调用并获得处理器资源时，线程就进入了运行状态。

这时，自动掉用该线程对象的run（）方法。

run（）方法定义了该线程的操作和功能。

4，堵塞状态一个正在执行的线程，因为某些原因，让出cpu并暂时终止自己的执行，进入堵塞状态。

在可执行状态下，若调用sleep（）、suspend（）、wait（）等方法，线程进入堵塞状态。

堵塞时不能进入排队对列，只有当引起堵塞的原因被消除后，线程才可以转入就绪状态。

5，死亡状态线程调用stop方法，或润、方法执行完，即处于死亡状态。

此线程不具有继续执行的能力。

停止线程stop已经过时。

如何停止线程呢？只有一种，run方法结束。

开启多线程运行，运行代码通常是循环结构。

只要控制主循环，就可以让run方法结束，也就是线程结束。

特殊情况：当线程处于了冻结状态。

就不会读取到标记。

那么线程就不会结束。

当没有指定的方式让冻结的线程恢复到运行状态时，这时就需要对冻结进行消除强制让线程恢复到运行状态中来。

这样就可以操作标记让线程结束。

Thread类提供该方法 interrupt（）；守护线程join：让一个线程强制运行，线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行。

join可以用来临时加入线程执行。

class Demo implements Runnable{public void run(){for(int x=0;x<70;x++){System.out.println(Thread.currentThread().getName()+"..."+x);}}}class JoinDemo{public static void main(String[] args){Demo d=new Demo();Thread t1=new Thread(d);Thread t2=new Thread(d);t1.start();t1.join();t2.start();for(int x=0;x<80;x++){System.out.println("main..."+x);}System.out.println("over");}}线程休眠：sleep（）：允许线程进入暂时的休眠。

直接使用Thread.sleep()方法。

线程中断：、、interrupt（）中断之后将执行catch中的代码。

后台线程：在java程序中，只要前台有一个线程在运行，则整个java进程都不会消失，此时应设置一个后台线程。

直接使用setDaemon()方法。

Thread t=new Thread(mt);//实例化Thread类对象t.setDaemon(true);//此线程在后台运行。

t.satrt();//启动该线程线程的优先级：在java的线程操作中，所有线程在运行前都会保持在就绪状态，那么此时，哪个线程优先级高，那个线程多线程就有可能先被执行。

设置优先级：setPriority();Thread t1=new Thread(new MyThread(),"线程A");//实例化线程对象Thread t2=new Thread(new MyThread(),"线程A");//实例化线程对象Thread t3=new Thread(new MyThread(),"线程A");//实例化线程对象t1.setPriority(Thread.MIN_PRIORITY); //设置线程优先级为最低t2.setPriority(Thread.MAX_PRIORITY); //设置线程优先级为最高t3.setPriority(Thread.NORM_PRIORITY); //设置线程优先级为中等t1.start(); //启动线程t2.start(); //启动线程t3.start(); //启动线程并非线程的优先级越高就一定会先执行，哪个线程先执行将由cpu的调度决定。

主线程优先级为中等级别。

线程的礼让yield方法将一个线程暂时让给其他线程执行，多线程的运行出现了安全问题：问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完， 另一个线程参与进来执行。

导致共享数据的错误。

解决办法：对多条操作共享数据的语句，只能让一个线程都执行完。

在执行过程中，其他线程不可以参与执行。

java对于多线程的安全问题提供了专业的解决方式。

就是同步代码块。

synchronized（对象）{需要被同步的代码;（看哪些语句在操作共享数据）}}对象如同锁。

持有锁的线程可以在同步中执行。

没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。

同步的前提：1，必须要有两个或者两个以上的线程。

2，必须是多个线程使用同一个锁。

必须保证同步中只能有一个线程在运行。

好处：解决了多线程的安全问题弊端：多个线程需要判断锁，较为消耗资源。

class Ticket implements Runnable{private static int tick=100;//定义成静态，生命周期太长。

Object obj=new Object();public void run(){while(true){synchronized(obj){if(tick>0){try{Thread.sleep(10);}catch(Exception e){}//有异常，不能抛(接口不能抛)System.out.println(Thread.currentThread().getName()+"sale:"+tick--);}}}}}main{Ticket t=new Ticket();//不是线程Thread t1=new Thread(t);//创建线程，里面有构造方法，可以接收Thread t2=new Thread(t);//创建线程Thread t3=new Thread(t);//创建线程Thread t4=new Thread(t);//创建线程t1.start();//开启线程，调用的是Thread中的run方法t2.start();t3.start();t4.start();}2，同步方法将一个方法设置成同步函数。

class MyThread implements Runnable{ //实现Runnable接口private int ticket=5; //一共5张票public void run(){ //覆写run（）方法for(int i=0;i<100;i++){ //超出票数循环this.sale(); //调用同步方法。

}}public synchronized void sale(){ //声明同步方法if(ticket<0){ //判断票是否有剩余try{Thread.sleep(300); //加入延迟}catch(InterruptedException e){e.printStackTrace();}System.out.println("卖票：ticket="+ticket--);}}}main{MyThread mt=new MyThread(); //定义线程对象Thread t1=new Thread(mt); //定义Thread对象Thread t1=new Thread(mt); //定义Thread对象t1.start();t2.start();}同步函数用的是哪一个锁呢？函数需要被对象调用。

那么函数都有一个所属对象引用。

就是this所以同步函数使用的锁就是this。

如果同步函数被静态修饰后，使用的锁是什么呢？通过验证，发现不在时this。

因为静态方法中也不可以定义this。

静态进内存是，内存中没有本类对象，但是一定有该类对应的字节码文件对象。

类名.class 该对象的类型是class静态的同步方法，使用的锁是该方法所在类的字节码文件对象。

类名.class多线程单例设计模式饿汉式class Single{private static final Single s=new Single();private Single(){}public static Single getInstance(){return s;}}懒汉式死锁同步中嵌套同步。

线程间通信：其实就是多个线程在操作同一个资源。

但是操作的动作不同。

wait（）；notify（）；唤醒notifyAll（）；都是用在同步中，因为要对持有监视器（锁）的线程操作。

所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义object类中呢？因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁。

只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。

不可以对不同锁中的线程进行唤醒。

也就是说，等待和唤醒必须是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。

JDK1.5中提供了多线程升级解决方案。

将同步Synchronized替换成实Lock操作。

将object中的wait，notify，notifyAll，替换了Condition对象。

该对象可以Lock锁 进行获取。

该示例中，实现了本方只唤醒对方操作。

注意：多个线程共享同一资源时需要进行同步，以保证资源操作的完整性，但是过多的同步就有可能产生死锁。

练习：创建两个线程，和主线程交替运行。

class Test extends Thread{public void run(){for(int x=0;x<60;x++){System.out.println((Thread.currentThread()==this)+"..."this.getName()+"run...."+x);}}}main{Test t1=new Test();Test t2=new Test();t1.start();t2.start();for(int x=0;x<60;x++){System.out.println("main...."+x);}}多线程运行出现了安全问题。