一、为什么要学习并发编程
1.发挥多处理的强大能力
2.建模的简单性
3.异步事件的简化处理
4.响应更加灵敏的用户界面
二、并发的缺点
1.安全性问题
多线程环境下
多个线程共享一个资源
对资源进行非原子性操作
2.活跃性问题（饥饿）
1、死锁
2、饥饿
饥饿与公平
1）高优先级吞噬所有低优先级的CPU时间片
2）线程被永久堵塞在一个等待进入同步块的状态
3）等待的线程永远不被唤醒
如何尽量避免饥饿问题
- 设置合理的优先级
- 使用锁来代替synchronized
3、活锁
3.性能问题
三、线程的状态
线程在一定条件下，状态会发生变化。线程一共有以下几种状态：
1、新建状态(New)：新创建了一个线程对象。
2、就绪状态(Runnable)：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于“可运行线程池”中，变得可运行，只等待获取CPU的使用权。即在就绪状态的进程除CPU之外，其它的运行所需资源都已全部获得。
3、运行状态(Running)：就绪状态的线程获取了CPU，执行程序代码。
4、阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。
阻塞的情况分三种：
(1)、等待阻塞：运行的线程执行wait()方法，该线程会释放占用的所有资源，JVM会把该线程放入“等待池”中。进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒，
(2)、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入“锁池”中。
(3)、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
5、死亡状态(Dead)：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
线程变化的状态转换图如下：
四、创建线程的多种方式
1、继承Thread类
public class Demo1 extends Thread {
public Demo1(String name) {
super(name);
}
@Override
public void run() {
while(!interrupted()) {
System.out.println(getName() + "线程执行了 .. ");
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Demo1 d1 = new Demo1("first-thread");
Demo1 d2 = new Demo1("second-thread");
d1.start();
d2.start();
// d1.stop();
d1.interrupt();
}
}
2、实现Runnable接口
public class Demo2 implements Runnable {
@Override
public void run() {
while(true) {
System.out.println("thread running ...");
}
}
public static void main(String[] args) {
Thread thread = new Thread(new Demo2());
thread.start();
}
}
3、匿名内部类的方式
public class Demo3 {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("runnable");
}
}) {
public void run() {
System.out.println("sub");
};
}.start();
}
}
4、带返回值的线程
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class Demo4 implements Callable<integer> {
public static void main(String[] args) throws Exception {
Demo4 d = new Demo4();
FutureTask<integer> task = new FutureTask<>(d);
Thread t = new Thread(task);
t.start();
System.out.println("我先干点别的。。。");
Integer result = task.get();
System.out.println("线程执行的结果为：" + result);
}
@Override
public Integer call() throws Exception {
System.out.println("正在进行紧张的计算....");
Thread.sleep(3000);
return 1;
}
}
/<integer>/<integer>
5、定时器（quartz）
import java.util.Timer;
import java.util.TimerTask;
public class Demo5 {
public static void main(String[] args) {
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
// 实现定时任务
System.out.println("timertask is run");
}
}, 0, 1000);
}
}
6、线程池的实现
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 线程池
* @author Administrator
*
*/
public class Demo6 {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 1000; i++) {
threadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
});
}
threadPool.shutdown();
}
}
7、Lambda表达式实现
import java.util.Arrays;
import java.util.List;
/**
* lambda并行计算
* @author Administrator
*
*/
public class Demo7 {
public static void main(String[] args) {
List<integer> values = Arrays.asList(10,20,30,40);
int res = new Demo7().add(values);
System.out.println("计算的结果为：" + res);
}
public int add (List<integer> values) {
values.parallelStream().forEach(System.out :: println);
return values.parallelStream().mapToInt( i -> i * 2).sum();
}
}
/<integer>/<integer>
8、Spring实现多线程
五、Synchronized原理与使用
1、内置锁
2、互斥锁
1、修饰普通方法
2、修饰静态方法
3、修饰代码块
public class Sequence {
private int value;
/**
* synchronized 放在普通方法上，内置锁就是当前类的实例
* @return
*/
public synchronized int getNext() {
return value ++;
}
/**
* 修饰静态方法，内置锁是当前的Class字节码对象
* Sequence.class
* @return
*/
public static synchronized int getPrevious() {
// return value --;
return 0;
}
public int xx () {
// monitorenter
synchronized (Sequence.class) {
if(value > 0) {
return value;
} else {
return -1;
}
}
// monitorexit
}
public static void main(String[] args) {
Sequence s = new Sequence();
// while(true) {
// System.out.println(s.getNext());
// }
new Thread(new Runnable() {
@Override
public void run() {
while(true) {
System.out.println(Thread.currentThread().getName() + " " + s.getNext());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while(true) {
System.out.println(Thread.currentThread().getName() + " " + s.getNext());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while(true) {
System.out.println(Thread.currentThread().getName() + " " + s.getNext());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
}
六、任何对象都可以作为锁，那么锁信息又存在对象的什么地方呢？
存在对象头中
对象头中的信息
Mark Word：线程id、Epoch、对象的分代年龄信息、是否是偏向锁、锁标志位
Class Metadata Address
Array Length
偏向锁
每次获取锁和释放锁会浪费资源
很多情况下，竞争锁不是由多个线程，而是由一个线程在使用。
只有一个线程在访问同步代码块的场景
重量级锁
七、设置线程优先级
public class Target implements Runnable {
@Override
public void run() {
while(true) {
System.out.println(Thread.currentThread().getName() + " ...");
// Thread.sleep(1);
}
}
}
public class Demo {
public static void main(String[] args) {
Thread t1 = new Thread(new Target());
Thread t2 = new Thread(new Target());
t1.setPriority(1);
t2.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
}
}
八、单例模式与线程安全性问题
饿汉式
没有线程安全性问题
public class Singleton {
// 私有化构造方法
private Singleton () {}
private static Singleton instance = new Singleton();
public static Singleton getInstance() {
return instance;
}
}
懒汉式
双重检查加锁解决线程安全性问题
public class Singleton2 {
private Singleton2() {}
//volatile 解决指令重排序导致的线程安全性问题、过多将导致cpu缓存优化失效
private static volatile Singleton2 instance;
/**
* 双重检查加锁
*
* @return
*/
public static Singleton2 getInstance () {
// 自旋 while(true)
if(instance == null) {
synchronized (Singleton2.class) {
if(instance == null) {
instance = new Singleton2(); // 指令重排序
// 申请一块内存空间 // 1
// 在这块空间里实例化对象 // 2
// instance的引用指向这块空间地址 // 3
}
}
}
return instance;
}
}
九、锁重入
public class Demo {
public synchronized void a () {
System.out.println("a");
// b();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void b() {
System.out.println("b");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String[] args) {
//同一个对对象将会阻塞
Demo d1= new Demo();
Demo d2= new Demo();
new Thread(new Runnable() {
@Override
public void run() {
d1.a();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
d2.b();
}
}).start();
}
}
十、自旋锁
import java.util.Random;
/**
* 多个线程执行完毕之后，打印一句话，结束
* @author worker
*
*/
public class Demo2 {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 线程执行...");
try {
Thread.sleep(new Random().nextInt(2000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " 线程执行完毕了...");
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 线程执行...");
try {
Thread.sleep(new Random().nextInt(2000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " 线程执行完毕了...");
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 线程执行...");
try {
Thread.sleep(new Random().nextInt(2000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " 线程执行完毕了...");
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 线程执行...");
try {
Thread.sleep(new Random().nextInt(2000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " 线程执行完毕了...");
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 线程执行...");
try {
Thread.sleep(new Random().nextInt(2000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " 线程执行完毕了...");
}
}).start();
while(Thread.activeCount() != 1) {
// 自旋
}
System.out.println("所有的线程执行完毕了...");
}
}
十一、死锁
public class Demo3 {
private Object obj1 = new Object();
private Object obj2 = new Object();
public void a () {
synchronized (obj1) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (obj2) {
System.out.println("a");
}
}
}
public void b () {
synchronized (obj2) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (obj1) {
System.out.println("b");
}
}
}
public static void main(String[] args) {
Demo3 d = new Demo3();
new Thread(new Runnable() {
@Override
public void run() {
d.a();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
d.b();
}
}).start();
}
}
十二、轻量级锁
Volatile
Volatile称之为轻量级锁，被volatile修饰的变量，在线程之间是可见的。
可见：一个线程修改了这个变量的值，在另外一个线程中能够读到这个修改后的值。
Synchronized除了线程之间互斥意外，还有一个非常大的作用，就是保证可见性
public class Demo2 {
public volatile boolean run = false;
public static void main(String[] args) {
Demo2 d = new Demo2();
new Thread(new Runnable() {
@Override
public void run() {
for(int i = 1;i<=10;i++) {
System.err.println("执行了第 " + i + " 次");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
d.run = true;
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while(!d.run) {
// 不执行
}
System.err.println("线程2执行了...");
}
}).start();
}
}
Lock指令
在多处理器的系统上
1、将当前处理器缓存行的内容写回到系统内存
2、这个写回到内存的操作会使在其他CPU里缓存了该内存地址的数据失效
硬盘 – 内存 – CPU的缓存
多个线程可以同时
十三、JDK提供的原子类原理及使用
1、原子更新基本类型、原子更新数组、原子更新抽象类型、原子更新字段
public class User {
private String name;
public volatile int old;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getOld() {
return old;
}
public void setOld(int old) {
this.old = old;
}
}
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicIntegerArray;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import java.util.concurrent.atomic.AtomicReference;
public class Sequence {
private AtomicInteger value = new AtomicInteger(0);
private int [] s = {2,1,4,6};
AtomicIntegerArray a = new AtomicIntegerArray(s);
AtomicReference<user> user = new AtomicReference<>();
AtomicIntegerFieldUpdater<user> old = AtomicIntegerFieldUpdater.newUpdater(User.class, "old");
/**
* @return
*/
public int getNext() {
User user = new User();
System.out.println(old.getAndIncrement(user));
System.out.println(old.getAndIncrement(user));
System.out.println(old.getAndIncrement(user));
a.getAndIncrement(2);
a.getAndAdd(2, 10);
return value.getAndIncrement();
}
public static void main(String[] args) {
Sequence s = new Sequence();
new Thread(new Runnable() {
@Override
public void run() {
// while(true) {
System.out.println(Thread.currentThread().getName() + " " + s.getNext());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
// }
}
}).start();
}
}
/<user>/<user>十四、Lock接口的认识与使用
Lock与Synchronized的区别：
Lock需要显示地获取和释放锁，繁琐能让代码更灵活
Synchronized不需要显示地获取和释放锁，简单
Lock的优势：
使用Lock可以方便的实现公平性
非阻塞的获取锁
能被中断的获取锁
超时获取锁
自己实现一个Lock
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Sequence {
private int value;
Lock lock = new ReentrantLock();
Lock l1 = new ReentrantLock();
/**
* @return
*/
public int getNext() {
lock.lock();
int a = value ++;
lock.unlock();
return a;
}
public static void main(String[] args) {
Sequence s = new Sequence();
new Thread(new Runnable() {
@Override
public void run() {
while(true) {
System.out.println(Thread.currentThread().getName() + " " + s.getNext());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while(true) {
System.out.println(Thread.currentThread().getName() + " " + s.getNext());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while(true) {
System.out.println(Thread.currentThread().getName() + " " + s.getNext());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
}
最后针对于互联网公司java程序员涉及到的绝大部分难题我做成了文档和架构视频资料免费分享给大家（包括Dubbo、Redis、Netty、zookeeper、Spring cloud、分布式、高并发等架构技术资料），希望能帮助到且找到一个好的工作，也节省大家在网上搜索资料的时间来学习，也可以关注我一下以后会有更多干货分享。
资料领取方式：
关注+转发后，私信关键词 【资料或者java】免费获取！
重要的事情说三遍，转发、转发、转发后再发私信，才可以拿到！
分享到:
閱讀更多 java高端開發 的文章
