多线程概述（二）

线程不安全的解决方法

线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。
      线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据。
 

解决方法一：同步代码块

格式：synchronized(锁对象){}

java任何对象都可以作为锁对象存在，举例

public class Demo {
    public static void main(String[] args) {
       Runnable r = new Ticket();
       /*这三个线程在使用o时，用的是同一把锁*/
       new Thread(r).start();
       new Thread(r).start();
       new Thread(r).start();
    }
    static class Ticket implements Runnable {
        //票数
        private int count = 10;
        private Object object = new Object();

        @Override
        public void run() {
            while (true) {
                synchronized (object) {
                    if (count > 0) {
                        synchronized (object) {
                            //卖票
                            System.out.println("正在准备卖票");
                            try {
                                Thread.sleep(1000);
                            } catch (InterruptedException e) {
                                System.out.println(e.getMessage());
                            }
                            count--;
                            System.out.println(Thread.currentThread().getName() + "出票成功，余票为： " + count);
                        }
                    }else break;
                }

            }
        }
    }
}

输出结果：

正在准备卖票
Thread-0出票成功，余票为： 9
正在准备卖票
Thread-0出票成功，余票为： 8
正在准备卖票
Thread-2出票成功，余票为： 7
正在准备卖票
Thread-1出票成功，余票为： 6
正在准备卖票
Thread-1出票成功，余票为： 5
正在准备卖票
Thread-1出票成功，余票为： 4
正在准备卖票
Thread-2出票成功，余票为： 3
正在准备卖票
Thread-0出票成功，余票为： 2
正在准备卖票
Thread-0出票成功，余票为： 1
正在准备卖票
Thread-0出票成功，余票为： 0

方法二：同步方法

public class Demo {
    public static void main(String[] args) {
       Runnable r = new Ticket();
       /*这三个线程在使用o时，用的是同一把锁*/
       new Thread(r).start();
       new Thread(r).start();
       new Thread(r).start();
    }
    static class Ticket implements Runnable {
        //票数
        private int count = 10;
        private Object object = new Object();
        @Override
        public void run() {
            while (true) {
                boolean flag = sale();
                if (!flag)
                    break;
            }
        }
        /*同步方法
        如果不是静态方法，谁调用这个方法谁就是锁对象；
        如果是静态方法，类名.class就是锁对象
        * */
        public synchronized boolean sale(){
            if (count > 0) {
                synchronized (object) {
                    //卖票
                    System.out.println("正在准备卖票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        System.out.println(e.getMessage());
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName() + "出票成功，余票为： " + count);
                }
            } return false;
        }
    }
}

方法三：显示锁Lock类，上面两种方法都是隐式锁

Lock`实现提供了比使用`synchronized`方法和语句可以获得的更广泛的锁定操作。  它们允许更灵活的结构，可能具有完全不同的属性，并且可能支持多个关联的Condition对象。 

格式：

Lock l = ...; l.lock(); try { // access the resource protected by this lock } finally { l.unlock(); } 

举例：

public class Demo {
    public static void main(String[] args) {
       Runnable r = new Ticket();
       /*这三个线程在使用o时，用的是同一把锁*/
       new Thread(r).start();
       new Thread(r).start();
       new Thread(r).start();
    }
    static class Ticket implements Runnable {
        //票数
        private int count = 10;
        //声明一把锁，ReentrantLock（)是lock类的子类
        Lock l = new ReentrantLock();
        @Override
        public void run() {
            while (true) {
                if (count >= 0) {
                    /*上锁锁住*/
                    l.lock();
                        //卖票
                        System.out.println("正在准备卖票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            System.out.println(e.getMessage());
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName() + "出票成功，余票为： " + count);
                    }else break;
                /*放开锁*/
                l.unlock();
                }
            }
        }
}

公平锁和非公平锁：

在java的锁机制中，公平和非公平的参考物是什么，个人而言觉得是相对产生的结果而立，简单的来说，如果一个线程组里，能保证每个线程都能拿到锁，那么这个锁就是公平锁。相反，如果保证不了每个线程都能拿到锁，也就是存在有线程饿死，那么这个锁就是非公平锁。

//fair的参数为true，是公平锁，false是非公平锁
Lock l = new ReentrantLock(true);