对线程的理解总结

说到线程，我们一定首先想到的是线程的创建，线程的创建一般有两种方式 一种是实现 Runnable 接口，另一种就是 继承 Thread 类 ，因为Java的单继承多实现机制，所以，优先选择 实现 Runnable 接口。

package test;

class ThreadTest extends Thread{

public void run(){

System.out.println("实现了Thread类");

}

}

class RunnableTest implements Runnable{

public void run(){

System.out.println("实现了runnable接口");

}

}

 

public class ThreadStartTest {

public static void main(String[] args) {

//直接继承了Thread ,创建一个Thread的实例

ThreadTest t1 = new ThreadTest();

//t1启动

t1.start();

//如果是实现了接口的线程类，需要用对象的实例作为Thread类构造方法的参数

Thread t2 = new Thread(new RunnableTest());

t2.start();

}

}

这儿就有一个我很久之前一直不了解的坑。那时因为不经常使用线程类，所以，对线程的开启仅停留在有两种方式上面。在使用继承的方式时，通过new xxxThread()的方式调用Start()方法，但使用接口的方式时 一直也是new xxxThread()d的方式，发现调不了start()方法，就调用了run()方法。.....其实这样是不对的，对于Java来说，通过new的方式调用内部run()方法一点问题都没有，但并不会开启新线程，那样做只会使用main线程。。正确的方式为Thread t2 = new Thread(new RunnableTest()); 然后调用start()方法。

总之一定要调用start()方法的。

1、那线程开启了就要考虑线程安全了

线程安全，说到底是数据的安全，我可不认识线程是谁，它安不安全，跟我没有半毛钱的关系。但数据不能不安全。这里就要提到内存了，因为，造成数据不安全的就是内存。

对于一个程序来说，就是一个进程，一个线程是其中的一部分。当系统为进程分配空间的时候，就会有公共空间（堆，公共方法区），和栈等。而造成不安全的就是这块公共的内存空间。

当一个线程在数据处理的过程中有另一个线程对数据进行了修改，就会造成数据不安全，程序混乱。这样我们就说这是线程不安全的。

1.1、怎么解决线程安全问题

解决线程安全问题，就要找到线程到底是怎么不安全的根本原因。其次安全与不安全是相对的。如果你的系统只有一个线程运行，或同一时间段不可能有两个线程同时运行。那也就不存在线程安全问题了。

那线程不安全是怎么造成的呢？

原因一：

“每条线程有自己的工作内存，线程的工作内存中保存了被该线程使用到的变量的主内存副本拷贝，线程对该变量的所有操作都必须在工作内存中进行，而不能直接读写主内存中的变量。不同线程之间也无法直接访问对方工作内存中的变量，线程间变量值的传递均需要通过主内存来完成。”

原因二：线程抢夺

根本原因：线程内的关于外部变量的语境，与真实外部语境不一致。

针对这几个原因，我们来提出解决的方案。

解决方案一：避重就轻

对于原因一中 线程的工作内存中保存了被该线程使用到的变量的主内存副本拷贝，那就不要拷贝，我们所有的方法的参数都使用方法的局部变量，这样，就不会产生从主内存拷贝的问题。当每一个线程来执行方法的时候，系统都会为该线程分配一块属于自己的栈内存，这样，每个执行这个方法的线程都会有属于自己的局部变量，那么操作自己的局部变量就不会产生安全问题了。

解决方法二：只读不写

对于原因一种的对主内存的拷贝，有时候是不能不拷贝的那，我们就要看看能不能只允许它读取，不允许修改，也就是使用 final 修饰等...，这样，你只能看看我的数据，不能修改，就不会造成安全问题了。

解决方案三：人手一份

就是把变量分给每一个线程，让他们独立运行。在是实际的开发当中我们可能会遇到变量在线程中共享的需求。这时我们可以使用 ThreadLocal 定义线程的变量，使用ThreadLocal 定义的变量只在本线程中有效，这样也不会有安全问题。

@RestController
@RequestMapping("/test")
public class TestController {
 8 
    static class MyThread implements Runnable {
        Test test;

        public MyThread(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            for (int i = 0; i < 3; i++) {
                test.dd();
            }

        }

    }

    static class Test {
        ThreadLocal<Integer> threadLocal = new ThreadLocal<>();

        public void dd() {
            try {
                if (threadLocal.get() == null)
                    threadLocal.set(0);
                Integer tt = threadLocal.get();
                tt += 60;
                threadLocal.set(tt);
                System.out.println(Thread.currentThread().getName() + "输出值为：" + threadLocal.get());

                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Test test = new Test();
        for (int i = 0; i < 3; i++) {
            MyThread myThread = new MyThread(test);
            new Thread(myThread).start();

        }
    }
}

在本例中有三个线程，变量使用 ThreadLocal 定义，通过 Test test = new Test(); 对线程传入相同的 Test 实例。这样避免使用不同的Test 实例 产生不同的ThreadLocal 变量对象。进而在 每个线程中循环3次进行 ThreadLocal 累加

上例运行结果如下：

可以看到线程之间没有产生累加，但同一线程中进行了累加。

解决方案四：加悲观锁

对于以上方法都不能满足我们的需求，那我们就只能采取更加严格的方式了，那就是加锁，只要加锁，那就要产生线程的阻塞，性能就会打折扣了。悲观锁就是悲观的认为只要我不加锁，那我的数据就会被其他线程修改，所以每次操作都要加锁，直到操作完成。

下面我将上面的代码修改一下，成为加悲观锁的情况：

public class TestController {

    static class MyThread implements Runnable{
        Test test;
        public MyThread(Test test){
            this.test=test;
        }
        @Override
        public void run() {
            for (int i = 0; i <3 ; i++) {
                test.dd();
            }

        }

    }
    static class Test{
        Integer threadLocal=0;
        Lock lock=new ReentrantLock();
        public  void dd(){
            try {
                lock.lock();
//            Integer tt=threadLocal.get();
                threadLocal+=60;
//            threadLocal.set(tt);
                System.out.println(Thread.currentThread().getName()+ "输出值为："+    threadLocal);

                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        Test test=new Test();
        for (int i = 0; i <3 ; i++) {
            MyThread myThread=new MyThread(test);
            new Thread(myThread).start();

        }
    }
}

在这个例子中我们把 ThreadLocal 替换为了普通的 Integer 变量，并使用了 Lock 进行加锁。我们同样开启三个线程，并在线程中进行3次循环。并执行累加，没有ThreadLocal 所有的线程公用一个变量，结果如下：

可以看到线程执行的顺序不一定，但输出的结果，没有出现错误。

 解决方案五：加乐观锁

乐观锁与悲观锁相对，乐观锁认为，大概率没有线程会修改我的数据，如果修改了那就只能重新执行操作。如果在高并发情况下使用乐观锁，可能会更加浪费系统资源。那具体怎么操作呢？

• synchronized是悲观锁，这种线程一旦得到锁，其他需要锁的线程就挂起的情况就是悲观锁。
• CAS操作的就是乐观锁，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。

参考：Java：CAS(乐观锁)

volatile 关键字

我们知道volatile关键字的作用是保证变量在多线程之间的可见性，它是java.util.concurrent包的核心，没有volatile就没有这么多的并发类给我们使用。