深入理解Java多线程与并发编程

一、多线程三大特性

多线程有三大特性：原子性、可见性、有序性。

原子性

(跟数据库的事务特性中的原子性类似，数据库的原子性体现是dml语句执行后需要进行提交)：
理解：即一个操作或多个操作，要么全部执行并且执行的过程中不会被任何因素打断，要么都不执行。
一个很经典的例子就是银行账户转账问题：
比如从账户a向账户b转1000元，那么必然包括2个操作：从账户a减去1000元，往账户b加上1000元。这2个操作必须要具备原子性才能保证不出现一些意外的问题。
我们操作数据也是如此，比如i = i+1；其中就包括，读取i的值，计算i，写入i。这行代码在java中是不具备原子性的，则多线程运行肯定会出问题，所以也需要我们使用同步synchronized和lock锁这些东西来确保这个特性了。
原子性其实就是保证数据一致、线程安全一部分，

可见性：

可见性是与java内存模型息息相关的。
当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
若两个线程在不同的cpu，那么线程1改变了i的值还没刷新到主存，线程2又使用了i，那么这个i值肯定还是之前的，线程1对变量的修改线程2没有看到，这就是可见性问题。

有序性：

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

例如：

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，因为这打破了依赖关系。
显然重排序对单线程运行是不会有任何问题，而多线程就不一定了，所以我们在多线程编程时就得考虑这个问题了。
多线程中保证有序性的方法：join()

二、java内存模型

jvm的内存结构为：堆、栈、方法区，不同于java的内存模型，java的内存模型是关于多线程相关的。

理解：共享内存模型指的是java内存模型(简称jmm)，jmm决定一个线程对共享变量的写入时，能对另一个线程可见。从抽象的角度来看，jmm定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存(main memory)中（局部变量不会存储在），每个线程都有一个私有的本地内存(local memory)，本地内存中存储了该线程以读/写共享变量的副本。本地内存是jmm的一个抽象概念，并不真实存在。它涵盖了缓存、写缓冲区、寄存器以及其他的硬件和编辑器优化。

总结：什么是java内存模型：java内存模型简称jmm，定义了一个线程对另一个线程可见。共享变量存放在主内存中，每个线程都有自己的本地内存，当多个线程同时访问一个数据的时候，可能本地内存没有及时刷新到主内存，所以就会发生线程安全问题。

三、volatile关键字

volatile关键字的作用：变量在多个线程之间可见。

volatile关键字是非原子性的，不能保证数据的原子性，只是能够把解决立马刷新到主内存中，不能解决并发问题。

如果想要保证数据的原子性，解决并发问题，需要使用并发包里的automicinteger原子类。

volatile与synchronized区别：
仅靠volatile不能保证线程的安全性（原子性）。

1. 1.volatile轻量级，只能修饰变量。synchronized重量级，还可修饰方法。
2. 2.volatile只能保证数据的可见性，不能用来同步，因为多个线程并发访问volatile修饰的变量不会阻塞。

synchronized不仅保证可见性，而且还保证原子性，因为只有获得了锁的线程才能进入临界区，从而保证临界区中的所有语句都全部执行。多个线程争抢synchronized锁对象时会出现阻塞。

synchronized会把主内存中的共享变量锁住，永远只有一个线程操作主内存的共享变量。

线程安全性包括两个方便：1.可见性 2.原子性

仅仅使用volatile不能保证线程安全性，而synchronized则可实现线程的安全性。

代码实现：

package chauncy.concurrentprogramming;

class threadvolatile extends thread {
    public volatile boolean flag = true;

    @override
    public void run() {
        system.out.println("子线程开始执行...");
        while (flag) {

        }
        system.out.println("子线程结束执行...");
    }

    public void isrun(boolean flag) {
        this.flag = flag;
    }
}

/**
 * @classdesc: 功能描述(volatile关键字的使用)
 * @author: chauncywang
 * @createtime: 2019年3月12日 上午10:17:14
 * @version: 1.0
 */
public class volatile {
    public static void main(string[] args) throws interruptedexception {
        threadvolatile threadvolatile1 = new threadvolatile();
        threadvolatile1.start();
        thread.sleep(300);
        /**
         * 如果不对变量加volatile关键字，则子线程不会停止运行 原因：线程之间是不可见的，读取的是副本，没有及时读取到主内存结果。
         * 解决办法：使用volatile关键字解决线程之间的可见性，强制线程每次读取该值的时候都去“主内存”中取值。
         */
        threadvolatile1.isrun(false);
        system.out.println("flag:" + threadvolatile1.flag);
    }
}

package chauncy.concurrentprogramming;

import java.util.concurrent.atomic.atomicinteger;

class volatilenoatomicthread extends thread {
    // private static volatile int count = 0;
    private static atomicinteger atomicinteger = new atomicinteger(0);

    @override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            // count++;
            atomicinteger.incrementandget();// count++
        }
        system.out.println(getname() + "-----" + atomicinteger);
    }
}

/**
 * @classdesc: 功能描述(volatile修饰不具有原子性(不具有同步性)，不能解决线程安全问题)
 * @author: chauncywang
 * @createtime: 2019年3月12日 上午10:39:30
 * @version: 1.0
 */
public class volatilenoatomic {
    public static void main(string[] args) {
        // 初始化10个线程
        volatilenoatomicthread[] volatilenoatomicthread = new volatilenoatomicthread[10];
        for (int i = 0; i < volatilenoatomicthread.length; i++) {
            // 创建每一个线程
            volatilenoatomicthread[i] = new volatilenoatomicthread();
        }
        for (int i = 0; i < volatilenoatomicthread.length; i++) {
            // 启动每一个线程
            volatilenoatomicthread[i].start();
        }
    }
}

四、treadlocal

1.什么是threadlocal？

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

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

threadlocal接口方法有4个：

1. void set(object value)设置当前线程的线程局部变量的值；
2. public object get()该方法返回当前线程所对应的线程局部变量；
3. public void remove()将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是jdk5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存的回收速度；
4. protected object initialvalue()返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(object)时才执行，并且仅执行1次。threadlocal中的缺省实现直接返回一个null。

2.threadlocal底层实现原理：

threadlocal通过thread.currentthread();获取当前线程

操作map集合：threadlocalmap

void set(object value)就是map.put(“当前线程”，值);

public object get()就是获取threadlocalmap然后操作后返回。

代码实现：

package chauncy.concurrentprogramming;

class res {
    // private int count=0;
    /*
     * 设置本地局部变量，和其他线程局部变量隔离开，互不影响
     */
    private threadlocal<integer> count = new threadlocal<integer>() {
        protected integer initialvalue() {
            // 设置当前线程局部变量的初始化值
            return 0;
        };
    };

    /**
     *
     * @methoddesc: 功能描述(生成订单号)
     * @author: chauncywang
     * @param: @return
     * @createtime: 2019年3月12日 下午2:23:57
     * @returntype: int
     */
    public integer getnum() {
        int count = this.count.get() + 1;
        this.count.set(count);
        return count;
    }
}

class threadlocaldemo extends thread {
    private res res;

    public threadlocaldemo(res res) {
        this.res = res;
    }

    @override
    public void run() {
        for (int i = 0; i < 3; i++) {
            try {
                thread.sleep(30);
            } catch (exception e) {
            }
            system.out.println(getname() + "----i:" + i + ",number:" + res.getnum());
        }
    }
}

/**
 * @classdesc: 功能描述(本地线程的使用：创建三个线程，每个线程生成自己独立的序列号)
 * @author: chauncywang
 * @createtime: 2019年3月12日 下午2:21:03
 * @version: 1.0
 */
public class threadlocaltest {
    public static void main(string[] args) {
        res res = new res();
        threadlocaldemo t1 = new threadlocaldemo(res);
        threadlocaldemo t2 = new threadlocaldemo(res);
        threadlocaldemo t3 = new threadlocaldemo(res);
        t1.start();
        t2.start();
        t3.start();
    }
}

五、线程池

1.为什么要使用线程池？

因为要通过线程池来管理线程，启动或者停止一个线程非常耗费资源，所以将线程交给线程池来管理能够节约内存。
一般在企业开发当中我们都使用线程池，通过spring去整合线程池，异步注解。

2.什么是线程池？

线程池是指在初始化一个多线程应用程序过程中创建一个线程集合，然后在需要执行新的任务时重用这些线程而不是新建一个线程。线程池中线程的数量通常完全取决于可用内存数量和应用程序的需求。然而，增加可用线程数量是可能的。线程池中的每个线程都有被分配一个任务，一旦任务已经完成了，线程回到池子中并等待下一次分配任务。

3.线程池作用：

基于以下几个原因，在多线程应用程序中使用线程池是必须的：

1. 1.线程池改进了一个应用程序的相应时间。由于线程池中的线程已经准备好且等待被分配任务，应用程序可以直接拿来使用而不用新建一个线程。
2. 2.线程池节省了clr为每个短生命周期任务创建一个完整的线程开销并可以在任务完成后回收资源。
3. 3.线程池根据当前在系统中运行的进程来优化线程时间片。
4. 4.线程池允许我们开启多个任务而不用为每个线程设置属性。
5. 5.线程池允许我们为正在执行任务的程序参数传递一个包含状态信息的对象引用。
6. 6.线程池可以用来解决处理一个特定请求最大线程数量限制问题。

4.线程池四种创建方式：

java通过executors(jdk1.5的并发包)提供四种线程池，分别为：

1. 1.newcachedthreadpool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
2. 2.newfixedthreadpool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
3. 3.newscheduledthreadpool 创建一个定长线程池，支持定时及周期性任务执行
4. 4.newsinglethreadexecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(fifo,lifo,优先级)执行。(一般不会使用)

总结：newcachedthreadpool 创建的线程，线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。newfixedthreadpool 每次执行传入参数大小个线程，其他线程在等待(企业中用的不多)。newscheduledthreadpool 使用schedule方法创建单位时间的延迟线程池。

代码实现：

package chauncy.concurrentprogramming.executors;

import java.util.concurrent.executorservice;
import java.util.concurrent.executors;

public class newcachedthreadpool {
    public static void main(string[] args) {
        // 创建可缓存线程池
        executorservice newcachedthreadpool = executors.newcachedthreadpool();
        // 执行execute方法表示创建了一个线程，类似于start
        for (int i = 0; i < 30; i++) {
            int index = i;
            // index++;
            newcachedthreadpool.execute(new runnable() {

                @override
                public void run() {
                    try {
                        thread.sleep(300);
                    } catch (interruptedexception e) {
                    }
                    // 内部类中使用的i必须是final,但是换成index后就不报错，因为jdk1.8进行了优化，能识别index是否被改变，如果把int
                    // index=i;下边的index++放开就会报错。
                    system.out.println(thread.currentthread().getname() + "----" + index);
                }
            });
        }
        // 关闭线程池
        newcachedthreadpool.shutdown();
    }
}

package chauncy.concurrentprogramming.executors;

import java.util.concurrent.executorservice;
import java.util.concurrent.executors;

public class newfixedthreadpool {
    public static void main(string[] args) {
        // newfixedthreadpool 每次最多只能执行三个，其他线程等待执行。
        executorservice newfixedthreadpool = executors.newfixedthreadpool(3);
        for (int i = 0; i < 10; i++) {
            int index = i;
            newfixedthreadpool.execute(new runnable() {
                public void run() {
                    try {
                        thread.sleep(1000);
                    } catch (interruptedexception e) {
                    }
                    system.out.println(thread.currentthread().getname() + "----i:" + index);
                }
            });
        }
    }
}

package chauncy.concurrentprogramming.executors;

import java.util.concurrent.executors;
import java.util.concurrent.scheduledexecutorservice;
import java.util.concurrent.timeunit;

public class newscheduledthreadpool {
    public static void main(string[] args) {
        // 入参为线程池大小，
        scheduledexecutorservice newscheduledthreadpool = executors.newscheduledthreadpool(5);
        // schedule执行定时任务线程池,第一个参数需要创建runnable接口对象，第二、三个参数表示多少个单位时间执行run方法。
        newscheduledthreadpool.schedule(new runnable() {
            public void run() {
                system.out.println("我是三秒钟之后执行。。。。");
            }
        }, 3, timeunit.seconds);
    }
}

package chauncy.concurrentprogramming.executors;

import java.util.concurrent.executorservice;
import java.util.concurrent.executors;

public class newsinglethreadexecutor {
    public static void main(string[] args) {
        executorservice newsinglethreadexecutor = executors.newsinglethreadexecutor();
        for (int i = 0; i < 10; i++) {
            int index = i;
            newsinglethreadexecutor.execute(new runnable() {
                public void run() {
                    system.out.println(thread.currentthread().getname() + "----i:" + index);
                }
            });
        }
    }
}

以上所述是小编给大家介绍的java多线程与并发编程详解整合，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对服务器之家网站的支持！

原文链接：https://blog.csdn.net/qq_39636602/article/details/88403281