线程安全

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

概述

如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。
线程安全问题都是由全局变量及静态变量引起的。
若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

如何保证线程安全：

1.把共享的变量数据标识为private
2.使用synchronized关键字同步方法或代码。

volidate关键字的使用

volatile是一个类型 修饰符 （type specifier）。它是被设计用来修饰被不同线程访问和修改的 变量 。如果没有volatile，基本上会导致这样的结果：要么无法编写多线程程序，要么 编译器 失去大量优化的机会。

Volidate 和Synchroinzed 区别

java中使用Volidate变量所需的编码较少，并且运行时开销也较少，但是它所能实现的功能也仅是 synchronized 的一部分。Synchronized是对Volidate的基础上增加了互斥的功能。
1.Volidate:只保证可见性，可以多个线程同时访问voliadte修饰的变量。
2.Synchroinzed：既保证了可见性又保证了互斥性。同时只能有一个线程去访问。 volatile 变量可以被看作是一种 “程度较轻的 synchronized”；与 synchronized 块相比，volatile 与锁相比，Volatile 变量是一种非常简单但同时又非常脆弱的同步机制，它在某些情况下将提供优于锁的性能和伸缩性。如果严格遵循 volatile 的使用条件 —— 即变量真正独立于其他变量和自己以前的值 —— 在某些情况下可以使用 volatile 代替 synchronized 来简化代码。然而，使用 volatile 的代码往往比使用锁的代码更加容易出错。
当使用volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存。

经典卖票的例子

public class Multithread implements Runnable
{

    //总票数
    private int ticket = 100;

    @Override
    public void run()
    {
        saleTicket();
        try
        {
            Thread.sleep(10);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }

    }

    public void saleTicket()
    {
        while (true)
        {
            if (ticket > 0)
            {
                System.out.println(Thread.currentThread().getName() + "  正在卖第" + ticket + "张票");
                ticket--;
            }
            else
            {
                System.out.println("余票不足!");
                break;
            }
        }
    }

    public static void main(String[] args)
    {
        Multithread mt = new Multithread();
        new Thread(mt, "窗口1").start();
        new Thread(mt, "窗口2").start();
        new Thread(mt, "窗口3").start();
        new Thread(mt, "窗口4").start();
    }
}

利用Synchroinzed 关键字进行同步锁

public class Multithread implements Runnable
{

    //总票数
    private int ticket = 100;

    //同步锁对象
    Object obj = new Object();

    /**
     * 利用synchronized关键字对代码块进行同步
     * 保证同一时间只有一个线程在操作共享变量 其余线程则等待该线程执行完毕后再执行
     * obj 对象锁可以是任意类型
     * 注意: 要保证对象锁是同一个
     */
    @Override
    public void run()
    {
        saleTicket();
        try
        {
            //线程睡眠10毫秒 每个线程都有执行机会
            Thread.sleep(10);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }

    }

    public void saleTicket()
    {
        while (true)
        {
            synchronized (obj){if (ticket > 0)
            {
                System.out.println(Thread.currentThread().getName() + "  正在卖第" + ticket + "张票");
                ticket--;
            }
            else
            {
                System.out.println("余票不足!");
                break;
            }
            }
        }
    }

    public static void main(String[] args)
    {
        Multithread mt = new Multithread();
        new Thread(mt, "窗口1").start();
        new Thread(mt, "窗口2").start();
        new Thread(mt, "窗口3").start();
        new Thread(mt, "窗口4").start();
    }
}

通过synchronized关键字对代码块进行同步（加锁），保证共享的变量同一时间只能有一个线程在操作。其他线程则等待该线程执行完毕后在进行操作，这样就保证了线程的同步和共享数据的安全！

注意

synchronized 同步代码块的锁可以是任意类对象（继承Thread类），这个对象必须是线程共享类（静态的）
synchronized 可以加在方法上，如果是静态方法synchronized的锁就是这个类的类对象，如果不是静态方法，synchronized 加在对象方法上，这个锁就是this

---

（未完待续)