Java 线程

线程
    线程概念
            你来到了一个只有一个服务员和一个顾客的餐馆，
            由于你很饿，叫服务员过来点菜，
            这时服务员却说:对不起，我对这位先生的服务还没有结束。
            之后就不理你了。------这就是没有使用线程。
        用了线程，这个服务员就可以在你和那位顾客之间进行切换，一会为你服务，一会为他服务。
        线程不同步------这位服务员正在为那位顾客服务，你却需要服务员的服务，两个人抢夺资源
        线程同步---------当你看到服务员忙碌的时候，就等到他执行完当前任务的时候，在找服务员服务。
        线程同步    //等待使用方结束
        线程不同步    //抢夺使用权限



    1.Thread                //多线程，(继承Thread后，重写run方法,
        1.1.Lock lock = new ReentrantLock();        //创建锁
            signal();                    //唤醒
            await();                    //等待    //可以在前面加锁方法，明确某对象等待
                //创建锁方法
            private Condition condition_pro = lock.newCondition();
            private Condition condition_con = lock.newCondition();
            condition_pro.await();        //等待
            condition_con.signal();        //唤醒
            lock.unlock();                //结束锁
            lock.lock();                //开启锁
        1.2.synchronized        //加锁,同步    //在锁中有线程执行则其他线程不可进入
            synchronized的4种用法
                1) 方法声明时使用: public synchronized void synMethod() {};
                2) 对某一代码块使用synchronized后跟括号,括号里是变量,一次只有一个线程进入该代码块
                      

                        public int synMethod(int a1){  
                            synchronized(a1) {  
                              //一次只能有一个线程进入  
                            }  
                        }          

 

                3) synchronized后面括号里是一对象,此时,线程获得的是对象锁 synchronized (this) {}
                4) synchronized后面括号里是类,此时,线程获得的是对象锁.
                        synchronized(A.class) {}
            1.2.1.有synchronized的地方不一定有wait,notify,notifyAll,
            1.2.2.有wait,notify的地方必有synchronized.这是因为wait和notify不是属于线程类，而是每一个对象都具有的方法，而且，这两个方法都和对象锁有关，有锁的地方，必有synchronized.
            1.2.3.如果要把notify和wait方法放在一起用的话，必须先调用notify后调用wait，因为如果调用完wait，该线程就已经不是current thread了.
            1.2.4 推荐使用notifyAll.

        1.4. 在资源竞争不是很激烈的情况下，Synchronized的性能要优于ReetrantLock，
        但是在资源竞争很激烈的情况下，Synchronized的性能会下降几十倍，但是ReetrantLock的性能能维持常态；

        1.3.className t = new className();        //创建一个类对象
            Thread t1 = new Thread(t);    //创建线程
            *.start启动多线程(public void run())
               

//匿名内部类 //用于临时需要多线程运算
                    new Thread(){
                        public void run(){
                            for(int x=0;x<10;x++){
                                System.out.println(Thread.currentTherad().getName()+"..."+x);
                            }
                        }
                    }.start

 

            线程状态指令
                t1.join();            //t1线程申请执行权，(t1线程先运行结束，其他线程才能继续执行)用于临时加入线程执行
                Thread.yield();        //暂停当前线程执行其他线程
                t1.setDaemon(true);    //将线程定义为守护线程(后台线程，依赖于前台，前台线程结束，后台线程自动结束)
            t1.setPriority(Thread.MAX_PRIORITY);    //设置线程优先级最大为10, 线程执行会偏向于大优先级,
                Thread.MIN_PRIORITY;        //最小为 1
                Thread.NORM_PRIORITY;        //默认优先级 5
        1.4.Thread.currentTherad().toString()        //返回线程名称，优先级，线程组
            Thread.currentTherad().getName();        //返回线程名称
        1.5.方法
            sleep(time)            //睡眠
            interrupt();            //清除线程特殊状态
            notify()            //唤醒
                notifyAll()            //唤醒全部
            wait()                //等待
        示例

/**
*　　间隔输出 xiaoqiang is man, xiaohong is woman
*    创建people类: 名字, 性别, 打印名字与性别
*    创建input,output类,继承Runnadle, 重写run 方法
*    在set与output中创建锁,设置一次唤醒另一线程, 本线程等待 
*/
public class ThreadDemo {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        People peo = new People();
//        peo.set("xiaoqiang", "man");
//        peo.output();
        
        Thread th1= new Thread(new Input(peo));
        Thread th2= new Thread(new Output(peo));
        
        th1.start();
        th2.start();
    }

}
class People {
    String name;
    String sex;
    boolean decide = false;
    public synchronized void set(String name,String sex){
        if(decide){
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        }
        this.name = name;
        this.sex = sex;
        decide = true;
        this.notify();
    }
    
    public synchronized void output(){
        if(!decide){
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        }
        
        System.out.println(name+" is "+sex);
        decide = false;
        this.notify();
    }
}

class Input implements Runnable{
    People peo;
    Input(People peo){
        this.peo = peo;
    }
    @Override
    public void run() {
        // TODO 自动生成的方法存根
        int x = 0;
        while(true){
            if(x==0){
                peo.set("xiaoqiang", "man");
            }else{
                peo.set("xiaohong", "woman");
            }
            x = (x+1)%2;
        }
    }
}

class Output implements Runnable{
    People peo;
    public Output(People peo) {
        // TODO 自动生成的构造函数存根
        this.peo = peo;
    }
    @Override
    public void run() {
        // TODO 自动生成的方法存根
        while(true){
            peo.output();
        }
    }
}

 

    Runnable            //多线程,实现接口，避免单继承的局限性