java线程复习

线程复习（扩展：静态的生命周期较长；接口中复写的方法如果出现异常，不能抛，只能try；）进程：是一个正在执行中的程序，该顺序是一个执行路径，是cpu在做着快速切换，执行着电脑里面很多程序。

线程：线程是进程中的内容，每个进程里面至少有一个线程，在某一时刻，只能有一个程序在运行（多核除外）扩展：其实更细节的说jvm，jvm启动时其实不止一个线程（主线程），还有一个垃圾回收装置的线程。

创建线程的第一种方式：继承Thread类步骤：1，定义类继承Thread，2复写Thread类中的run方法(目的：将自定义的代码存储在run方法中，让线程运行)；3调用线程的start方法，（该方法有两个作用：启动线程，调用run方法）。

Demo d=new Demo();Demo d1=new Demo();Demo d2=newDemo();--->d.start();d1.start();d2.start();（中间千万别加hread t = new Thread(d)）创建线程的第二种方式：实现runnable接口步骤：1，定义类实现Runnable接口；2，覆盖Runnable接口中的run方法；3，通过Thread类建立线程对象；4，将Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。

5，调用Thread类中的start方法，开启线程并调用Runnable接口子类的run 方法。

Ticket t=new Ticket();---->Thread t1= new Thread(t); Thread t2= new Thread(t); Thread t3= new Thread(t);----->t.start() t1.start(); t2.start();实现方法和继承方式有什么区别？-------->1，继承Thread：线程代码存放在Thread子类的run方法中；实现Runnable：线程代码存在接口的子类的run方法中。

2，实现方式的好处：避免了单继承的局限性，在定义线程时，建议使用实现方式(面试的时候经常考)为什么要覆盖run方法？答：Thread类是用于描述线程，该类定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。

也就是说Thread类中的run方法，用于存储线程要运行的代码获取线程对象：Thread.currentThread()获取线程名称：getName()设置线程名称：setName或者构造函数多线程运行出现安全问题解决办法（安全问题：卖票程序）：同步代码块；格式：synchronized(对象){ 需要被同步的代码。

}注释：哪些代码需要被同步？---->看哪些代码在操作共享数据。

对象如同锁，持有锁的线程可以在同步中执行，没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有锁。

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

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

3，同步有两种表现形式：同步代码块和同步函数。

(public synchronized void show(){}) 同步弊端：每次都要判断锁，消耗了资源。

同步函数用的是哪个锁？---->函数需要被对象调用，那么函数都有一个所属对象引用，就是this，所以同步函数使用的锁就是this。

Try{Thread.sleep(10);}catch(Exception e){} ---->这句话的意思是让主线程睡起，缓和其他线程的执行速度。

同步函数public synchronized void show(){}--->使用的锁是this。

如果同步函数被静态函数修饰后，锁是什么呢？---->通过验证，发现不是this，因为静态方法中也不可以定义this，静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象----->类名.class,该对象的类型是class即public static synchronized void show(类名.class){}同步的弊端：死锁---->同步中嵌套同步，而锁不同。

（面试经常会考，请给我写个死锁程序）class Test implements Runnable{private boolean flag;Test(boolean flag){this.flag = flag;}public void run(){if(flag){synchronized(MyLock.locka){System.out.println("if locka");synchronized(MyLock.lockb){System.out.println("if lockb");}}}else{synchronized(MyLock.lockb){System.out.println("else lockb");synchronized(MyLock.locka){System.out.println("else locka");}}}}}class MyLock{static Object locka = new Object();static Object lockb = new Object();}class DeadLockTest{public static void main(String[] args){Thread t1 = new Thread(new Test(true));Thread t2 = new Thread(new Test(false));t1.start();t2.start();}倘若出现安全问题，使用同步一定要铭记这两点：是不是两个或以上线程？（注意：两个货以上线程都要同步）用的是同一锁吗？}多线程之间的通讯问题：其实就是多个线程在操作同一资源，但操作的动作不同。

Wait() notify() notiftAll()都必须用在同步当中，因为当前线程必须拥有此对象的监视器，即锁。

注意：Wait() notify() notiftAll()这都必须表示锁对应的对象，eg：r.wait()。

package .Thread;/*线程间通讯：其实就是多个线程操作同一资源，但是操作的动作不同两个操作同一共享数据时，可以用等待唤醒机制wait;notify();notifyAll();这些都要使用在同步中，因为要对持有监视器（锁）的线程操作所以要使用在同步中，因为只有同步才具有锁为什么这些操作线程的方法要定义在Object类中？因为这些方法在操作同步中的线程时，都必须要标识他们的所操作线程持有的锁只有同一个锁上的被等待线程，可以被同一锁上notify唤醒不可以对不同锁中的线程进行唤醒也就是说，等待和唤醒必须是同一个锁*/class Resouer{String name;String sex;Boolean flag = false;//必须有标记public synchronized void set(String name,String sex){if(flag)try{wait();}catch(Exception e){}=name;this.sex=sex;flag=true;notify();}public synchronized void get(){if(!flag)try{wait();}catch(Exception e){}System.out.println(name+";;;;;;"+sex);flag=false;notify();}}class Input implements Runnable{private Resouer r;Input(Resouer r){this.r = r;}public void run(){int x = 0;while(true){if(x==0)r.set("maike","man");else{r.set("麦克","男");}x = (x+1)%2;}}}class Output implements Runnable{private Resouer r;Output(Resouer r){this.r = r;}public void run(){while(true){r.get();}}}class InputOutputDemo{public static void main(String[] args) {Resouer p = new Resouer();Input in = new Input(p);Output out = new Output(p);Thread t1 = new Thread(in);Thread t2 = new Thread(out);t1.start();t2.start();}}/** notify:只能用于两个线程的唤醒机制，超过就会发生安全问题* notifyAll：可以唤醒两个以上线程* */package .Thread;public class InputOutputDemo2 {public static void main(String[] args) {Resource r= new Resource();Pro p= new Pro(r);Dec d = new Dec(r);Thread t1= new Thread(p);Thread t2= new Thread(p);Thread t3= new Thread(d);Thread t4= new Thread(d);t1.start();t2.start();t3.start();t4.start();}}class Resource{private String name;private int num=1;boolean flag=false;public synchronized void set(String name){while(flag)//这里不用if，因为两个以上线程操作同一数据时，会去判断。

If是判断一次，while要判断多次。

try{this.wait();}catch(Exception e){}=name+"---"+num++;System.out.println(Thread.currentThread().getName()+"生产者；；；；"+);flag=true;this.notifyAll();}public synchronized void get(){while(!flag)try{this.wait();}catch(Exception e){}System.out.println(Thread.currentThread().getName()+"；；；；消费者；；；；"+);flag=false;this.notifyAll();}}class Pro implements Runnable{private Resource r;Pro(Resource r){this.r=r;}public void run(){while(true)r.set("商品");}}class Dec implements Runnable{private Resource r;Dec(Resource r){this.r=r;}public void run(){while(true)r.get();}}package .Thread;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** notify:只能用于两个线程的唤醒机制，超过就会发生安全问题* notifyAll：可以唤醒两个以上线程* */public class InputOutputDemo3 {public static void main(String[] args) {Resource r= new Resource();Pro p= new Pro(r);Dec d = new Dec(r);Thread t1= new Thread(p);Thread t2= new Thread(p);Thread t3= new Thread(d);Thread t4= new Thread(d);t1.start();t2.start();t3.start();t4.start();}}/** jdk1.5中提供了多线程升级解决方案，将同步synchronized替换成了* 现实lock操作，将object中的wait，notify，notifyAll替换成了Condition对象* 该对象可以lock锁，进行获取。