JAVA--线程

自定义线程

方式：

方式一： 1.自定义一个类继承Thread方法        2.重写Thread类的run方法，把自定义线程的任务代码写在run方法中        3.创建Thread的子类对象，并且调用start方法开启线程。        （线程一旦开启，就会直接调用run方法，不可直接在main中调用）方式二： 1.自定义一个类实现Runnable接口；        2.实现Runable接口的run方法，把自定义线程的任务写在run方法上。        3.创建Runable实现类对象。        4.创建Thread类对象，并把Runnable的实现类对象作为实参传递。        5.调用Thread对象的start方法开启线程。

线程的状态：

1.创建：新创建了一个线程对象。2.可运行：线程对象创建后，其他线程调用了该对象的start()方法。该状    态的线程位于可运行线程池中，变得可运行，等待获取cpu的执行权。3.运行：就绪状态的线程获取了CPU执行权，执行程序代码。4.阻临时塞: 阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止    运行。直到线程进入就绪状态，才有机会转到运行状态。5.死亡：线程执行完它的任务时。

常用线程的方法：

1.Thread(String name)     初始化线程的名字 2.getName()             返回线程的名字 3.setName(String name)    设置线程对象名 4.sleep(int Millis)                 线程睡眠指定的毫秒数。 5.getPriority()  返回当前线程对象的优先级 默认线程的优先级是5 6.setPriority(int newPriority) 设置线程的优先级         虽然设置了线程的优先级，但是具体的实现取决于底层的操作系统的     实现（最大的优先级是10 ，最小的1 ， 默认是5）。 7.currentThread()      返回CPU正在执行的线程的对象

样例代码：

//方式一：class TalkThread extends Thread{    public  void run()    {        int j=0;        while(j<50)        {            j++;            System.out.println("正在聊天");        }    }}class VedioThread extends Thread{    public VedioThread(String name)    {        super(name);    }    public  void run() {        //System.out.println(Thread.currentThread().getName());        int i=0;        while(i<50)        {            i++;            System.out.println("在视屏。。。。。。");            /*try{                Thread.sleep(100);         //sleep() 是静态方法，可以直接由类名调用            }catch(InterruptedException e){                e.printStackTrace();            }*/        }    }}public class Demo3 {    public static void main(String[] args) {        TalkThread ss = new TalkThread();        ss.start();        //System.out.println( Thread.currentThread().getName());        ss.setName("小号");        VedioThread hh = new VedioThread("nihao");        hh.start();        hh.setPriority(10);        //System.out.println("线程名" + Thread.currentThread().getName());    }}  // 方式二：class SaleTicket implements Runnable {    int num=50;    public void run(){         while(true){            synchronized("锁"){                if(num>0){                    System.out.println(Thread.currentThread().getName()+"卖" + num);                    num--;                }                else {                    System.out.println("卖完。。。");                    break;                }            }        }    }}public class Demo3 {    public static void main(String[] args) {        SaleTicket  dd = new SaleTicket();     //Runnable 实现类对象并不是线程对象。        Thread aa = new Thread(dd,"小明");    // 实参传送，就是将Runnable的run方法作为线程的任务代码去执行。        Thread bb = new Thread(dd,"小云");        Thread cc = new Thread(dd,"小华");        aa.start();        bb.start();        cc.start();    }}

线程同步

同步代码块：

 synchronized(锁对象){  需要同步的代码； }          

注意的细节：

1.任何一个对象都可以作为锁对象；2.在同步代码块中调用sleep方法，并不是释放锁对象；3.只有真正存在线程安全时才能用同步代码块，否则会降低效率；4.多线程操作的锁对象必须是唯一共享的。

样例代码：

class SaleTicket extends Thread{    static int num = 50;    public SaleTicket(String name)    {        super(name);    }    public  void run() {        synchronized("锁对象"){            while(true)            {                 if(num>0){                 System.out.println(Thread.currentThread().getName()+" sale "+num);                 try{                 Thread.sleep(100);                 }catch(InterruptedException e){                     e.printStackTrace();                 }                 num--;                }                else{                    System.out.println(Thread.currentThread().getName()+"票已卖完。。");                    break;                }            }        }    }}public class Demo1 {    public static void main(String[] args) {         SaleTicket aa = new SaleTicket("窗口1");         SaleTicket bb = new SaleTicket("窗口2");         SaleTicket cc = new SaleTicket("窗口3");         aa.start();         bb.start();         cc.start();    }}

同步函数：

用synchronized修饰一个函数

注意细节：

1.一个非静态的同步函数的锁对象是this对象，静态同步函数的锁对象是    当前函数所属类的字节码对象。2.同步函数的锁对象是固定的。

死锁：

存在多个线程和多个共享资源时易产生死锁

样例代码：

class DeadSuo extends Thread{    public DeadSuo(String name)    {        super(name);    }    public  void run() {        if("丈夫".equals(Thread.currentThread().getName())){            synchronized("遥控器"){                   System.out.println("丈夫拿到遥控器，准备拿电池。。");                   synchronized("电池"){                       System.out.println("丈夫拿到了电池，打开了电视。。");                   }            }        }else if("妻子".equals(Thread.currentThread().getName())){            synchronized("电池"){                   System.out.println("妻子拿到电池，准备拿遥控器。。");                   synchronized("遥控器"){                       System.out.println("妻子了拿遥控器，打开了电视。。");                   }            }        }    }}public class Demo1 {    public static void main(String[] args) {        DeadSuo aa = new DeadSuo("丈夫");        DeadSuo bb = new DeadSuo("妻子");         aa.start();         bb.start();    }} 

wait 和 notify 方法：

1.wait 和 notify 方法都属于 Obeject 对象，都必须要在同步代码块或同步函数中使用，都必须用锁对象调用。2.wait：告诉当前线程放弃执行权，并放弃监视器（锁）并进入阻塞状        态(在线程池中等待)，直到其他线程持有获得执行权，并持有了相同的监视器（锁）并调用notify为止。3.notify：唤醒持有同一个监视器（锁）中调用wait的第一个线程，例如，餐馆有空位置后，等候就餐最久的顾客最先入座。注意：被唤醒的线程是进入了可运行状态。等待cpu执行权。4.notifyAll：唤醒持有同一监视器中调用wait的所有的线程。

样例代码：

// 生产者先生产一个，消费者再消费一个。。。class Product{    String name;    double price;    boolean flag=false;}class Productor extends Thread{    Product p;    public Productor(Product p){        this.p = p;    }    public void run(){        int i=0;        while(true){            synchronized(p){                    if(p.flag==false){                        if(i%2==0){                            p.name = "苹果";                            p.price= 2.0;                        }                        else{                            p.name = "香蕉";                            p.price = 6.0;                        }                        p.flag=true;                        System.out.println("生产了"+p.name+"价格"+p.price);                        i++;                        p.notify();                     }                    else{                        try {                            p.wait();                        } catch (InterruptedException e) {                            e.printStackTrace();                        }                    }                }        }    }}class Consumer extends Thread{    Product p;    public Consumer(Product p){        this.p = p;    }    public void run(){        while(true){            synchronized(p){                if(p.flag==true){                    System.out.println("消费了"+p.name+"价格"+p.price);                    p.flag=false;                    p.notify();                }                else {                    try {                        p.wait();                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            }        }    }}public class Demo1 {    public static void main(String[] args) {        Product p = new Product();        Productor aa = new Productor(p);        Consumer bb = new Consumer(p);         aa.start();         bb.start();    }}

守护线程（后台线程）：

1.一个线程默认都不是守护线程。2.在一个线程中只剩下守护线程时，守护线程也会死亡。

样例代码：

public class Demo1 extends Thread{    public Demo1(String name){        super(name);    }    public void run(){        for(int i=0; i<100; i++){            System.out.println("更新包目前下载"+i+"%");            if(i==100) {                System.out.println("更新完毕");            }            try{                Thread.sleep(1000);            }catch(InterruptedException e){                e.printStackTrace();            }        }    }    public static void main(String[] args)    {        Demo1 d = new Demo1("后台线程");        //d.setDaemon(true);  //设置守护线程，true 为真。        System.out.println("是守护线程吗?" + d.isDaemon());  //判断是否为守护线程        d.start();        for(int i=0; i<100; i++){            System.out.println(Thread.currentThread().getName()+":" +i);        }    }}

join 线程：

样例代码：

class Mon extends Thread{    public void run(){        System.out.println("妈妈炒菜没酱油");        System.out.println("妈妈让儿子买酱油。。");         Son r = new Son();         r.start();         try {            r.join();   //  一个线程中如果有join，那么该线程必须让步给加入的线程，当加入的线程执行完毕后再执行        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("妈妈炒菜没酱油");    }}class Son extends Thread{    public void run(){        System.out.println("儿子买酱油");        try {            Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }       }}public class Demo1{      public static void main(String[] args)    {         Mon d = new Mon();         d.start();    }}