什么是线程安全？

为什么有线程安全问题？

当多个线程同时共享，同一个全局变量或静态变量，做写的操作时，可能会发生数据冲突问题，也就是线程安全问题。但是做读操作是不会发生数据冲突问题。

抢火车的例子：

一号窗口和二号窗口同时出售火车第九九张,部分火车票会重复出售。

结论发现，多个线程共享同一个全局成员变量时，做写的操作可能会发生数据冲突问题。

二、线程安全解决办法:

问:如何解决多线程之间线程安全问题

答:使用多线程之间同步synchronized或使用锁(lock)。

问:为什么使用线程同步或使用锁能解决线程安全问题呢？

答:将可能会发生数据冲突问题(线程不安全问题)，只能让当前一个线程进行执行。代码执行完成后释放锁，让后才能让其他线程进行执行。这样的话就可以解决线程不安全问题。

问:什么是多线程之间同步

答:当多个线程共享同一个资源,不会受到其他线程的干扰。

问:什么是多线程同步

答:当多个线程共享同一个资源,不会受到其他线程的干扰。

三、同步的方式

1.synchronized加在方法上，同步方法2.synchronized包住代码块，同步码块

(1)在方法上加synchronized

package com.bigdata.thread;

/**
 * @created by imp ON 2019/8/28
 * 使用抢火车票的例子实现 多线程安全问题
 */
public class TicketDemo implements Runnable{
    int tickets = 100;

    public  void run() {
        while (tickets>0){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();

            }
            sale();
        }

    }

    public synchronized void sale() {
        if (tickets > 0) {
            System.out.println(Thread.currentThread().getName() + ",出售 第" + (101 - tickets) + "  票");
            tickets--;
        }
    }

}

class  Main{
    public static void main(String[] args) {
        System.out.println(1);
        TicketDemo  ticketDemo= new TicketDemo();
        Thread t1=new Thread(ticketDemo,"窗口1");
        Thread t2=new Thread(ticketDemo,"窗口2");
        t1.start();
        t2.start();
    }
}

窗口2,出售 第88  票
窗口2,出售 第89  票
窗口1,出售 第90  票
窗口2,出售 第91  票
窗口1,出售 第92  票
窗口2,出售 第93  票
窗口1,出售 第94  票
窗口1,出售 第95  票
窗口2,出售 第96  票
窗口1,出售 第97  票
窗口2,出售 第98  票
窗口2,出售 第99  票
窗口1,出售 第100  票

（2）使用代码块加synchronized

package com.bigdata.thread;

/**
 * @created by imp ON 2019/8/28
 * 使用抢火车票的例子实现 多线程安全问题
 */
public class TicketDemo implements Runnable{
  private   int tickets = 100;
  private  Object obj=new Object();

    public  void run() {
        while (tickets>0){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();

            }
            sale();
        }

    }

    public  void sale() {
        synchronized (obj){
            if (tickets > 0) {
                System.out.println(Thread.currentThread().getName() + ",出售 第" + (101 - tickets) + "  票");
                tickets--;
            }
        }

    }

}

class  Main{
    public static void main(String[] args) {
        System.out.println(1);
        TicketDemo  ticketDemo= new TicketDemo();
        Thread t1=new Thread(ticketDemo,"窗口1");
        Thread t2=new Thread(ticketDemo,"窗口2");
        t1.start();
        t2.start();
    }
}

3.如果是两个线程对象如何实现同步

因为new了两个对象，如果tickets（火车票数）、obj(代码块的锁对象） 是静态的，他们在方法区，可以实现共享，同步

如果不是静态的，就是两个对象的属性，锁与票数都不是同一个，无法实现同步

答：什么是静态同步函数？

方法上加上static关键字，使用synchronized 关键字修饰 或者使用类.class文件。

静态的同步函数使用的锁是  该函数所属字节码文件对象

可以用 getClass方法获取，也可以用当前  类名.class 表示。

package com.bigdata.thread;

/**
 * @created by imp ON 2019/8/28
 * 使用抢火车票的例子实现 多线程安全问题
 */
public class TicketDemo implements Runnable{
  private  static int tickets = 100;
  private static Object obj=new Object();

    public  void run() {
        while (tickets>0){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();

            }
            sale();
        }

    }

    public  void sale() {
        synchronized (obj){
            if (tickets > 0) {
                System.out.println(Thread.currentThread().getName() + ",出售 第" + (101 - tickets) + "  票");
                tickets--;
            }
        }

    }

}

class  Main{
    public static void main(String[] args) {
        System.out.println(1);
        TicketDemo  ticketDemo1= new TicketDemo();
        TicketDemo  ticketDemo2= new TicketDemo();
        Thread t1=new Thread(ticketDemo1,"窗口1");
        Thread t2=new Thread(ticketDemo2,"窗口2");
        t1.start();
        t2.start();
    }
}

4.静态同步方法：static synchronized void sale()相当于,synchronized（当前类.class),字节码加锁，

    public  void sale() {
        synchronized (TicketDemo.class){
        if (tickets > 0) {
            System.out.println(Thread.currentThread().getName() + ",出售 第" + (101 - tickets) + "  票");
            tickets--;
        }
    }

    }

    public static synchronized void sale() {
            if (tickets > 0) {
                System.out.println(Thread.currentThread().getName() + ",出售 第" + (101 - tickets) + "  票");
                tickets--;
            }

    }

总结：

Synchronized(this)
锁住该代码块的对象，等访问该对象的线程执行完，其他线程才可以执行。
Synchronized(xxx.class)
 锁住该类，所有访问该类的线程，一次只有一个可以执行。
其他
A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。
B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制

四、多线程的死锁问题

 什么是多线程死锁？

答:同步中嵌套同步,导致锁无法释放

五、Threadlocal

什么是Threadlocal

ThreadLocal提高一个线程的局部变量，访问某个线程拥有自己局部变量。

当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

ThreadLocal的接口方法

ThreadLocal类接口很简单，只有4个方法，我们先来了解一下：

• void set(Object value)设置当前线程的线程局部变量的值。

• public Object get()该方法返回当前线程所对应的线程局部变量。

• public void remove()将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。

• protected Object initialValue()返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。

我的理解是相当于广播变量一样，将这个公共变量广播给每个线程，每个线程单独去操作这个变量

六、多綫程的特性

多线程有三大特性

原子性、可见性、有序性

什么是原子性

即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

一个很经典的例子就是银行账户转账问题：
比如从账户A向账户B转1000元，那么必然包括2个操作：从账户A减去1000元，往账户B加上1000元。这2个操作必须要具备原子性才能保证不出现一些意外的问题。

我们操作数据也是如此，比如i = i+1；其中就包括，读取i的值，计算i，写入i。这行代码在Java中是不具备原子性的，则多线程运行肯定会出问题，所以也需要我们使用同步和lock这些东西来确保这个特性了。

原子性其实就是保证数据一致、线程安全一部分，

什么是可见性

当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

若两个线程在不同的cpu，那么线程1改变了i的值还没刷新到主存，线程2又使用了i，那么这个i值肯定还是之前的，线程1对变量的修改线程没看到这就是可见性问题。

什么是有序性

程序执行的顺序按照代码的先后顺序执行。

一般来说处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。如下：

int a = 10;    //语句1

int r = 2;    //语句2

a = a + 3;    //语句3

r = a*a;     //语句4

则因为重排序，他还可能执行顺序为 2-1-3-4，1-3-2-4
但绝不可能 2-1-4-3，因为这打破了依赖关系。
显然重排序对单线程运行是不会有任何问题，而多线程就不一定了，所以我们在多线程编程时就得考虑这个问题了。

原文地址：https://www.cnblogs.com/hejunhong/p/11427234.html