线程的操作

1.用之前的继承，实现接口，内部类，lambda表达式来创建线程。

2.创建完线程后，用线程对象来调用start()方法启动线程。

3.等待线程用方法join()，谁调用就是让另一个线程等待这个调用的线程执行完。

3.休眠当前线程sleep()，也可以正在括号内设置休眠时间。

线程的六种状态

1.NEW:把Tread对象创建好了，但还没有调用start()方法启动。

2.RUNNABLE:就绪状态，处于这个状态的线程就是在就绪队列中，随时可以被调度到CPU上，如果代码中没有sleep，也没有进行其他的可能导致阻塞的操作，代码大概率处在这个状态。

3.BLOCKED:当前线程在等待锁(后面会说)，导致了阻塞。

4.WAITING:当前线程在等待唤醒，导致了阻塞。

5.TIMED_WAITING:代码中调用了sleep，就会进入到这个状态，就是说当前线程在一定时间内是阻塞状态。

6.TERMINATED:操作系统中的线程已经执行完毕，销毁了，但是Tread对象还在获取到的状态。

线程安全问题

线程安全问题是整个线程中最重要最复杂的问题，1.是因为操作系统调度线程的时候是随机的，正因为这样的随机性就可能导致程序执行出现了一些BUG，这就导致了线程不安全的问题，如果这样的随机性没有带来BUG就认为代码是线程安全的。2.还有导致线程不安全的原因是多个线程对同一个变量进行修改操作。3.针对变量的操作不是原子的。4.内存可见性也会影响线程的安全。5.指令重排序也会影响线程安全问题

例如：使用两个线程，对同一个整型变量进行自增操作，但结果却不是预期结果

public class test10 {
    private static int count=0;

    public static void main(String[] args) throws InterruptedException {
        Object l=new Object();
        Thread thread=new Thread(()->{
            for(int i=0;i<50000;i++){
//                synchronized (l) {
//                    count++;
//                }
                count++;
            }
        });
        Thread thread1=new Thread(()->{
            for (int i = 0; i <50000; i++) {
//                synchronized (l) {
//                    count++;
//                }
                count++;
            }
        });
        thread.start();
        thread1.start();

        thread.join();
        thread1.join();

        System.out.println("count:"+count);
    }

这个两个线程各自自增50000，但最后结果却不是100000，

那么如何解决这样的问题：加锁

在java中最常用的加锁关键字synchronized，一定要会读这个单词，给方法加上一个锁离开方法就会解锁，当一个线程加锁成功的时候，其他线程尝试加锁就会触发阻塞等待，阻塞会持续到加锁线程运行完解锁为止，给上述代码加锁就会达到预期的运行结果。synchronized不光能保证指令的原子性，同时也能保证内存的可见性，被synchronized包裹起来的代码相当于手动禁止了编译器的优化，

public class test10 {
    private static int count=0;

    public static void main(String[] args) throws InterruptedException {
        Object l=new Object();
        Thread thread=new Thread(()->{
            for(int i=0;i<50000;i++){
                synchronized (l) {
                    count++;
                }
            }
        });
        Thread thread1=new Thread(()->{
            for (int i = 0; i <50000; i++) {
                synchronized (l) {
                    count++;
                }
            }
        });
        thread.start();
        thread1.start();

        thread.join();
        thread1.join();

        System.out.println("count:"+count);
    }

volatile关键字：volatile和原子性无关，但能够保证内存可见性