Java学习：多线程

多线程

线程是依赖于进程而存在的。
A:进程 正在运行的应用程序
B:线程 进程的执行路径，执行单元

多线程的两种方案：
继承Thread类：需重写run()方法。
实现Runable接口

启动线程用的是 start()方法

start()和run()的区别
start():1.开启线程 2.执行run()方法里面的代码
run():执行的是线程里面执行的代码，并不会开启线程

为什么要重写run()
因为每个线程需要执行的代码都是都是不一样的，
我们需要将每个线程自己独立执行的代码写到run()方法中执行

线程不可以多次启动

线程的调度和控制
线程休眠(Thread.sleep(毫秒值))
线程名称（setName(),getName();）
线程的调度及优先级setPriority(10)（注意默认值是5，区间在1-10之间）
什么叫线程优先级：说白了就是设置你抢占cpu执行权抢占到的概率

多线程安全问题
A:是否是多线程环境
B:是否有共享数据
C:是否有多条语句操作共享数据

如何解决多线程安全问题
线程安全执行效率就低
A:同步代码块（测试不是同一个锁的情况，测试是同一个锁的情况）
synchronized(对象) {
需要被同步的代码。
}
需求：1.测试不是同一把锁的时候线程安全吗？ 2.如果是同一把锁线程安全吗？
两个问题：1.对象是什么 ？
答：任意对象 ，相当于是一把锁，只要线程进去就把锁锁上
2.需要同步的代码？
答：被线程执行的代码

B:锁对象问题
a:同步代码块（定义一个抽象类，里面专门定义一个锁）
任意对象

b:同步方法（仅适用于实现runable接口）
public synchronized void sellTicket(){同步代码}
this

c:静态同步方法
类的字节码对象
public static synchronized void sellTicket() {
需要同步的代码
}

代码如下：

            //同步代码块
            synchronized (new Object()) {//t1,t2,t3三个线程不共享同一把锁每个线程都有自己的议案锁
            //synchronized (obj) {//这样3个线程才可以共享同一把锁    
            if (ticket>0) {
                    //考虑到实际的生活中，我们需要给每一个线程加入一定的延迟，模拟一下这种效果
                    try {
                        Thread.sleep(100);
                        /**
                         * 分析：为什么会出现两张100张票
                         * t1抢占到cpu的执行权，此时ticket=100,但是此刻休眠了
                         * 此时被t2抢占到了cpu的执行权，此时ticket=100,
                         * t1,t2分别睡了100毫秒之后，分别醒来了。。
                         * t1此时出售第100张票
                         * t2此时出售第100张票
                         */
                        
                        /**
                         * 分析：为什么会出现0张票和-1张票
                         * 假设此时票池中仅剩1张票了，
                         * t1进来休眠了
                         * t2进来休眠了
                         * t3进来休眠了
                         */
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    
                    System.out.println(Thread.currentThread().getName()+"正在出售第："+ticket--+"张票");
                    /**
                     * t1醒来，出售的是第1张票，此时tickt=0
                     * t2醒来，出售第0张票，此时ticket=-1
                     * t3醒来，出售第-1张票，此时ticket=-2
                     */
                    
                    /**
                     * ticket--这个动作一共包含几步：
                     * 1.打印出ticket此刻本身的值
                     * 2.ticket自减1
                     * 3.将自减之后的ticket的最新的值赋值给变量ticket
                     */
                }
            }
            //当被同步的代码执行完毕之后，t1手里拿着的obj这个锁才会被释放，
            //t1,t2,t3重新抢占cpu的执行权，谁抢到了继续拿着obj这个锁，执行同步代码块中的内容
        

    MyThread mt = new MyThread();
        
        //创建三个窗口
        Thread t1 = new Thread(mt);
        Thread t2 = new Thread(mt);
        Thread t3 = new Thread(mt);
        
        //给每一个窗口设置姓名
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        
        //开启窗口进行售票
        t1.start();
        t2.start();
        t3.start();

运行部分结果如图;

同步方法代码：

同步方法：同步方法是将synchronized关键字加到方法上,同步方法的锁是this
    private synchronized void sellTicket() {    
        if (ticket>0) {
                //考虑到实际的生活中，我们需要给每一个线程加入一定的延迟，模拟一下这种效果
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
                System.out.println(Thread.currentThread().getName()+"正在出售第："+ticket--+"张票");
            
        }
    }

静态同步方法：

private static synchronized void sellTicket() {    
    if (ticket>0) {
            //考虑到实际的生活中，我们需要给每一个线程加入一定的延迟，模拟一下这种效果
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
            System.out.println(Thread.currentThread().getName()+"正在出售第："+ticket--+"张票");
        
    }

匿名内部类的方式使用多线程
new Thread() {
public void run() {
...
}
}.start();

new Thread(new Runnable(){
public void run() {
...
}
}).start();

联系代码如下：

//方式1：
        new Thread(){
            //重写的方法
            @Override
            public void run() {
                for (int i = 0; i <10; i++) {
                    System.out.println(i);
                }
            }
        }.start();
        
        //方式2
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <10; i++) {
                    System.out.println(i);
                }
            }
        }).start();

JDK5的Lock锁，我们之前造的所有的锁都没有手动释放锁
static Lock lock = new ReentrantLock();
枷锁：lock.lock();
释放锁：lock.unlock();
可以让我们明确的知道在哪里加锁和释放锁。
依然写一个卖票的demo，用lock枷锁释放锁，
为了保证我们创建的锁一定会被释放，用一下代码进行改进
try{....}finally{.....}

//定义100张票
    int ticket = 100;
    Object obj = new Object();
    //创建一个锁
    Lock lock = new ReentrantLock();
    
    @Override
    public void run() {
        while (true) {
            try{
                //加上锁,获取锁
                lock.lock();
                if (ticket>0) {
                        //考虑到实际的生活中，我们需要给每一个线程加入一定的延迟，模拟一下这种效果
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        
                        System.out.println(Thread.currentThread().getName()+"正在出售第："+ticket--+"张票");
                    }
            }finally{
                //这里面的代码一定会被执行
                //释放锁
                lock.unlock();
            }
            }
    
    }

死锁问题
同步嵌套，锁里面套了一个锁，出现同步嵌套

boolean flag;
    
    //提供一个有参构造
    public DieThread(boolean flag){
        this.flag = flag;
    }
    
    @Override
    public void run() {
        if (flag) {
            synchronized (MyLock.objA) {
                System.out.println("if"+"objA");
                synchronized (MyLock.objB) {
                    System.out.println("if"+"objB");
                }
            }
            
        }else {
            synchronized (MyLock.objB) {
                System.out.println("else"+"objB");
                synchronized (MyLock.objA) {
                    System.out.println("else"+"objA");
                }
            }
            
        }
        
    }

线程等待和唤醒机制（案例演示：waitThread,NotifyThread,MyLock,Test）
锁对象调用wait()锁对象调用notify()

注意： 　　
wait和sleep的区别
线程等待，在等待的同时释放锁，而sleep（）方法在执行的过程中是不会释放锁的

//让等待线程处于等待状态
            try {
                MyLock.obj.wait();//当线程处于等待状态的时候，线程就不会继续往下执行了
                                  //线程在处于等待的时候，会释放掉自己手中的锁
                                 //sleep()这个方法，在线程休息的时候会释放锁码？
                                //答：不会
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        System.out.println("我被唤醒了");

public void run() {
        synchronized (MyLock.obj) {
            //唤醒等待线程
            MyLock.obj.notify();//唤醒正在等待的线程，唤醒的等待线程的锁对象，必须和等待线程的锁对象一致
        }
    }

WaitThread wt = new WaitThread();
        wt.start();
        
        //睡上5秒钟之后唤醒等待线程
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
        //创建唤醒线程对象
        NotifyThread nt = new NotifyThread();
        nt.start();