wordpress邮件wp smtp深圳关键词排名seo

---

前言

“清琴浊酒莺花日，雨笠烟蓑蟹稻乡。棠荫渐高身渐隐，已将心事托渔郎”   —张英 《赠何匡山次梅村先生韵》

1 线程池

1.1 线程池概述

       线程池也是可以看做成一个容器，在该容器中存储很多个线程。

1.1.1 线程池存在的意义

       系统创建一个线程的成本是比较高的，频繁的创建和销毁线程对系统的资源消耗非常大，所为了提高性能，我们就可以采用线程池。线程池在启动的时，会创建大量空闲线程，当我们向线程池提交任务的时，线程池就会启动一个线程来执行该任务。等待任务执行完毕以后，线程并不会死亡，而是再次返回到线程池中称为空闲状态。等待下一次任务的执行。

1.1.2 Executors默认线程池

       1.常见方法

// 1.创建一个默认的线程池
static ExecutorService newCachedThreadPool()
// 2.创建一个指定最多线程数量的线程池
static newFixedThreadPool(int nThreads)

       2.代码实现 :

package com.syh;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class MyThread {public static void main(String[] args) throws InterruptedException {// 1,创建一个默认的线程池对象ExecutorService executorService = Executors.newCachedThreadPool();executorService.submit(()->{System.out.println(Thread.currentThread().getName() + "在执行了");});// 2,等待2秒Thread.sleep(2000);executorService.submit(()->{System.out.println(Thread.currentThread().getName() + "在执行了");});executorService.shutdown();}
}

1.2 线程状态介绍

       线程对象在不同的时期有不同的状态，一共有6种状态

1.2.1 线程状态源码

public class Thread {public enum State {/* 新建 */NEW , /* 可运行状态 */RUNNABLE , /* 阻塞状态 */BLOCKED , /* 无限等待状态 */WAITING , /* 计时等待 */TIMED_WAITING , /* 终止 */TERMINATED;}// 获取当前线程的状态public State getState() {return jdk.internal.misc.VM.toThreadState(threadStatus);}}

1.2.2 线程状态含义

线程状态	具体含义
NEW	一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程象，没有线程特征。
RUNNABLE	当我们调用线程对象的start方法，那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程，线程一经启动并不是立即得到执行，线程的运行与否要听令与CPU的调度，那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格，但是并没有真正的执行起来而是在等待CPU的度。
BLOCKED	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
WAITING	一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种，分别是调用Object.wait()、join()方法。处于等待状态的线程，正在等待其他线程去执行一个特定的操作。例如：因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll()；一个因为join()而等待的线程正在等待另一个线程结束。
TIMED_WAITING	一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种，分别是：Thread.sleep(long)，Object.wait(long)、join(long)。
TERMINATED	一个完全运行完成的线程的状态。也称之为终止状态、结束状态

1.2.3 线程状态转换图

2 原子性

2.1 volatile关键字

1. 问题 :

当A线程修改了共享数据时，B线程没有及时获取到最新的值，如果还在使用原先的值，就会出现问题

• 堆内存是唯一的，每一个线程都有自己的线程栈。

• 每一个线程在使用堆里面变量的时候，都会先拷贝一份到变量的副本中。

• 在线程中，每一次使用是从变量的副本中获取的。

2. Volatile解决 : 强制线程每次在使用的时候，都会看一下共享区域最新的值,代码示例如下：

package com.syh;public class Money{public static volatile int money = 1000;
}

package com.syh;public class MyThread1 extends Thread{@Overridepublic void run() {Money.money -= 100;System.out.println("李默然：" + Money.money);}
}

package com.syh;public class MyThread2 extends Thread{@Overridepublic void run() {System.out.println("林北辰：" + Money.money);}
}

package com.syh;public class Test {public static void main(String[] args) {MyThread1 t1 = new MyThread1();t1.start();MyThread2 t2 = new MyThread2();t2.start();}
}

2.2 synchronized解决

1. synchronized解决步骤 :

• 线程获得锁

• 清空变量副本

• 拷贝共享变量最新的值到变量副本中

• 执行代码

• 将修改后变量副本中的值赋值给共享数据

• 释放锁

2. 代码实现 :

package com.syh;public class Money{public static Object lock = new Object();public static int money = 1000;
}

package com.syh;public class MyThread1 extends Thread{@Overridepublic void run() {synchronized (Money.lock){Money.money -= 100;System.out.println("李默然: " + Money.money);}}
}

package com.syh;public class MyThread2 extends Thread{@Overridepublic void run() {synchronized (Money.lock){System.out.println("林北辰：" + Money.money);}}
}

package com.syh;public class Test {public static void main(String[] args) {MyThread1 t1 = new MyThread1();t1.start();MyThread2 t2 = new MyThread2();t2.start();}
}

2.3 原子性

       原子性就是要么所有的操作都执行，要么所有的操作都不执行，多个操作是一个不可以分割的整体。

2.4 AtomicInteger类

java从JDK1.5开始提供了AtomicInteger类，这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式，常用方法如下:

public AtomicInteger()：	   			    // 1.初始化一个默认值为0的原子型Integer
public AtomicInteger(int initialValue)： // 2.初始化一个指定值的原子型Integerint get():   			 				 // 3.获取值
int getAndIncrement():      			 // 4.以原子方式将当前值加1，注意，这里返回的是自增前的值。
int incrementAndGet():     				 // 5.以原子方式将当前值加1，注意，这里返回的是自增后的值。
int addAndGet(int data): // 6.以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果。
int getAndSet(int value):   			 // 7.以原子方式设置为newValue的值，并返回旧值。

代码实现 :

package com.syh;import java.util.concurrent.atomic.AtomicInteger;public class MyAtom {public static void main(String[] args) {AtomicInteger ac = new AtomicInteger();System.out.println(ac);AtomicInteger ac2 = new AtomicInteger(10);System.out.println(ac2);}
}

2.5 悲观锁和乐观锁

synchronized和CAS的区别是什么?

1. 相同点
       在多线程情况下，都可以保证共享数据的安全性。

2.不同点

• 悲观锁：synchronized总是从最坏的角度出发，认为每次获取数据的时候，别人都有可能修改。所以在每次操作共享数据之前，都会上锁。

• 乐观锁：cas是从乐观的角度出发，假设每次获取数据别人都不会修改，所以不会上锁。只不过在修改共享数据的时候，会检查一下，别人有没有修改过这个数据。