前言

随着多核处理器的发展，已经从当年的遥不可及变得家喻户晓；目前市场上的绝大多数中高档计算机都是采用多核处理器，因此对多核处理器的利用变得普遍起来，在java编程中，针对多核处理器的并发编程慢慢的被java程序员所接受，Java并发编程已成为目前Java程序员必须掌握的一项关键性技能；Java并发编程可以让软件应用等更加高效的运行，本章将由浅入深的介绍Java的并发编程。

1.1线程基础

进程: 资源分配的最小单位

线程：Cpu调度的最小单位，共享进程中的资源，必须依附于进程

并行：同一时刻运行进行的任务

并发：与时间有关，在单位时间段内处理的任务数

高并发编程的意义、好处和注意事项：

1、充分利用cpu的资源

2、加快用户响应的时间

3、模块化、异步化

1.1.1三种创建/使用线程的方法

1.1.1.1创建

       //继承Thread
       private static class useThread extends Thread
       {
              @Override
              public void run()
              {
                    super.run();
                    System.out.println("useThread extends Thread has running....");
              }        
       }
    
       //实现Runnable接口
       private static class useRunnable implements Runnable
       {
              @Override
              public void run()
              {
                  System.out.println("useRunnable implements Runnable has                                     
                                                          running....");
                    
              }
             
       }

       //实现Callable接口
       private static class useCallable implements Callable<Integer>
       {
              @Override
              public Integer call() throws Exception
              {
                    System.out.println("useCallable implements Callable has 
                                                                 running....");
                     return 5201314;
              }
       }

1.1.1.2 使用

       //继承Thread
       useThread use_thread=new useThread();
       use_thread.start();

       //实现Runnable接口
       useRunnable use_runnable=new useRunnable();
       Thread runnableThread=new Thread(use_runnable);
       runnableThread.start();

       //实现Callable接口
       useCallable use_callable=new useCallable();
       FutureTask<Integer> futureTask=new FutureTask<>(use_callable); //包装
       Thread callableThread=new Thread(futureTask); //传入Thread
       callableThread.start();
       Integer integer=futureTask.get(); //取出数据

说明：Callable接口这种方法我们接触的较少，这种与Runnable差不多，只是多了一个回传数据的功能，Callable接口要用FutureTask来封装后再用Thread生成调用start（），利用FutureTask可以取的回传的数据。

1.1.2线程补充

让Java里的线程安全停止工作

interrupt() 不会去中断线程，只是把一个中断标志位置为true

isInterrupted()、static方法interrupted() 来检查中断标志位

interrupt（）方法让线程安全中断，在run（）方法中使用sleep方法会抛出InterruptException的异常，这时候需要在catch中重新将中断标志位置为true，即再次interrupt（）一下，才可以正常使用interrupt（）方法正常安全停止线程。

线程常用方法和线程的状态

Yield方法，是让当前线程让出cpu时间，os依然可以选中当前线程

Join方法，当前线程A等待thread线程终止之后才从thread.join()返回。线程Thread除了提供join()方法之外，还提供了join(long millis)和join(longmillis,int nanos)两个具备超时特性的方法。这两个超时方法表示，如果线程thread在给定的超时时间里没有终止，那么将会从该超时方法中返回。

ThreadLocal类型：

ThreadLocal类型的变量是所有线程共享的，且不会应为一个线程对其更改而影响其他线程的调用（还是调用原来的值）

private static final ThreadLocal<Integer> threadId =

new ThreadLocal<Integer>() {

@Override protected Integer initialValue() {

return 1;

}

};

Volatile类型：

volatile类型的变量是所有线程共享的，但会应为一个线程对其更改而影响其他线程的调用（调用更改后的值）---（可见性）

Volatile只保证内存可见性，不保证操作的原子性；某个变量只有一个线程进行修改，其他的线程都是读取，这个时候要求可见性，低原子性：Volatile

private volatile int age = 100000; //定义赋值

正是因为Volatile的这种特点，当多个线程对同一个Volatile操纵时会更加容易产生线程安全性问题。

额外干货：

并发程序正确地执行，必须要保证原子性、可见性以及有序性。只要有一个没有被保证，就有可能会导致程序运行不正确：

原子性：一个操作或多个操作要么全部执行完成且执行过程不被中断，要么就不执行。Java.util.concurrent.atomic包中包括了原子变量类，这些类用来实现数字和对象引用的原子状态转换。

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

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

对于单线程，在执行代码时jvm会进行指令重排序，处理器为了提高效率，可以对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证保存最终执行结果和代码顺序执行的结果是一致的。

原文链接：https://blog.csdn.net/u010796790/article/details/52155664

线程的优先级

通过一个整型成员变量priority来控制优先级，优先级的范围从1~10，默认优先级是5，在不同的JVM以及操作系统上，线程规划会存在差异，有些操作系统甚至会忽略对线程优先级的设定。

守护线程（了解）

Daemon线程是一种支持型线程，因为它主要被用作程序中后台调度以及支持性工作。这意味着，当一个Java虚拟机中不存在非Daemon线程的时候，Java虚拟机将会退出。可以通过调用Thread.setDaemon(true)将线程设置为Daemon线程。我们一般用不上，比如垃圾回收线程就是Daemon线程。

Daemon线程被用作完成支持性工作，但是在Java虚拟机退出时Daemon线程中的finally块并不一定会执行。在构建Daemon线程时，不能依靠finally块中的内容来确保执行关闭或清理资源的逻辑。

下接Java并发编程高级部分：

谢谢阅读！欢迎评论交流！

Java并发编程入门

前言