本文详述了Java并发编程中多线程的相关概念，包括进程与线程的区别、多线程创建方式（如继承Thread、实现Runnable和Callable）、线程同步（如synchronized和volatile对比）、死锁及wait/notify机制。还探讨了JUC包中的并发容器，特别是ConcurrentHashMap的实现原理和使用场景。
JUC多线程(三天) 第一天
1. 进程和线程的区别
进程: 有独立的内存空间,进程中的数据存放空间(堆空间和栈空间)是独立的,至少有一个线程
线程: 堆空间是共享的,栈空间是独立的,线程消耗的资源比进程小的多
注意:
Java程序的进程里面至少包含两个线程,主线程也就是main()方法线程, 另一个是垃圾回收机制线程.每当使用java命令执行一个类时, 实际上都会启动一个JVM ,每一个JVM实际上就是一个在操作系统中启动了一个线程. java本身具备了垃圾回收机制,所以在Java运行时至少会启动两个线程.
2. 多线程的创建
1.继承Thread类 重写run()方法
public static void main(String[] args) {
new CreateThread().start();
new CreateThread().start();
}
static class CreateThread extends Thread{
@Override
public void run() {
// super.run();
String name = Thread.currentThread().getName();
for (int i = 0; i < 5; i++) {
System.out.println(name+"内容是"+i);
}
}
}
2. 实现Runnable接口 重写run方法
注意:实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管 是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的 API来控制线程的。
public static void main(String[] args) {
CreateRunnabl createRunnabl = new CreateRunnabl();
new Thread(createRunnabl).start();
new Thread(createRunnabl).start();
}
static class CreateRunnabl implements Runnable{
public void run() {
String name = Thread.currentThread().getName();
for (int i = 0; i < 5; i++) {
System.out.println(name+"内容是"+i);
}
}
}
//第二种方式
public static void main(String[] args) throws InterruptedException {
new Thread(new Runnable() {
public void run() {
String name = Thread.currentThread().getName();
for (int i = 0; i < 5; i++) {
System.out.println(name+"内容是"+i);
}
}
}).start();
new Thread(new Runnable() {
public void run() {
String name = Thread.currentThread().getName();
for (int i = 0; i < 5; i++) {
System.out.println(name+"内容是"+i);
}
}
}).start();
}
}
3. 实现Callable接口
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//实现Callable接口
public class CallableTest {
public static void main(String[] args) {
//执行Callable 方式，需要FutureTask 实现实现，用于接收运算结果
FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyCallable());
new Thread(futureTask).start();
//接收线程运算后的结果
try {
Integer sum = futureTask.get();
System.out.println(sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i < 100; i++) {
sum += i;
}
return sum;
}
}
4. 线程池
线程池提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提交了响应速度。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//线程池实现
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
//创建线程池
ExecutorService executorService = Executors.newFixedThreadPool(10);
ThreadPool threadPool = new ThreadPool();
for(int i =0;i<5;i++){
//为线程池分配任务
executorService.submit(threadPool);
}
//关闭线程池
executorService.shutdown();
}
}
class ThreadPool implements Runnable {
@Override
public void run() {
for(int i = 0 ;i<10;i++){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
3. 实现Runnable接口比继承Thread类所具有的优势
-
适合多个相同的程序代码的线程去共享同一个资源
-
可以避免java中的单继承的局限性
-
增加程序的健壮性,实现解耦操作,代码可以被多个线程共享, 代码和数据独立
-
线程池只能放入实现Runnable或者callabe类线程, 不能直接放入继承Thread的类
4. 线程同步
-
同步代码块
//创建锁 Object loke=new Object(); //第一种线程安全问题 同步代码块 synchronized (loke) { //可能会产生线程安全问题的代码 if (ticket > 0) { System.out.println(name + "卖票" + ticket); ticket--; } } -
同步方法
//第二种线程安全问题 同步方法 public synchronized void sell(String name){ //可能会产生线程安全问题的代码 try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } if (ticket > 0) { System.out.println(name + "卖票" + ticket); ticket--; } } } -
lock锁
//设置一个锁 Lock lock= new ReentrantLock(); //第三种线程安排 设置锁 同步 lock.lock(); if (ticket > 0) { System.out.println(name + "卖票" + ticket); ticket--; } lock.unlock(); }
综合案例: 卖火车票案例
package com.itcast.thread;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Demo5Ticket {
public static void main(String[] args) {
//创建线程任务对象
Ticket ticket = new Ticket();
//创建一个窗口对象
Thread t1 = new Thread(ticket,"窗口1");
Thread t2 = new Thread(ticket,"窗口2");
Thread t3 = new Thread(ticket,"窗口3");
//卖票
t1.start();
t2.start();
t3.start();
}
static class Ticket implements Runnable{
//创建锁
// Object loke=new Object();
//设置一个锁
Lock lock= new ReentrantLock();
private int ticket=10;
public void run() {
String name = Thread.currentThread().getName();
while (true){
sell(name);
if (ticket<=0) {
break;
}
}
}
// public void sell(String name){
//第二种线程安全问题 同步方法
public synchronized void sell(String name){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
/*
//第一种线程安全问题 同步代码块
synchronized (loke) {
//可能会产生线程安全问题的代码
if (ticket > 0) {
System.out.println(name + "卖票" + ticket);
ticket--;
}
}
*/
//第三种线程安排 设置锁 同步
lock.lock();
if (ticket > 0) {
System.out.println(name + "卖票" + ticket);
ticket--;
}
lock.unlock();
}
}
}
5. 死锁
多线程死锁: 同步中嵌套同步,导致锁无法释放
死锁解决方法: 不要在同步中嵌套同步
案例说明:
package com.itcast.thread;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Demo6Ticket {
public static void main(String[] args) {
//创建线程任务对象
Ticket ticket = new Ticket();
//创建一个窗口对象
Thread t1 = new Thread(ticket, "窗口1");
Thread t2 = new Thread(ticket, "窗口2");
Thread t3 = new Thread(ticket, "窗口3");
//卖票
t1.start();
t2.start();
t3.start();
}
static class Ticket implements Runnable {
//创建锁
Object loke=new Object();
private int ticket = 100;
public void run() {
String name = Thread.currentThread().getName();
while (true) {
if ("窗口1".equals(name)) {
//同步代码块
synchronized (loke) {//线程一 (窗口1) 获得锁lock锁
sell(name);
}
} else {
sell(name);
}
if (ticket <= 0) {
break;
}
}
}
private synchronized void sell(String name){//线程二 (窗口2) 获取this锁
//第一种线程安全问题 同步代码块
synchronized (loke) {
//可能会产生线程安全问题的代码
if (ticket > 0) {
System.out.println(name + "卖票" + ticket);
ticket--;
}
}
}
}
}
关于wait和notify方法例子 : 一个人进站出站
package com.itcast.thread;
public class Demo7WaitAndNotify {
public static void main(String[] args) {
State state = new State();
InThread inThread = new InThread(state);
OutThread outThread = new OutThread(state);
Thread in = new Thread(inThread);
Thread out = new Thread(outThread);
in.start();
out.start();
}
//控制状态
static class State{
//状态标识
public String flag="车站外";
}
static class InThread implements Runnable{
private State state;
public InThread(State state) {
this.state = state;
}
public void run() {
while(true) {
synchronized (state) {
//可能会产生线程安全问题的代码
if ("车站内".equals(state.flag)) {
try {
//如果在车站内,就不用进站,等待,释放锁
state.wait();
} catch (InterruptedException e) {
// e.printStackTrace();
}
}
System.out.println("进站");
state.flag = "车站内";
//唤醒state等待进程
state.notify();
}
}
}
}
static class OutThread implements Runnable{
private State state;
public OutThread(State state) {
this.state = state;
}
public void run() {
while(true) {
synchronized (state) {
//可能会产生线程安全问题的代码
if ("车站外".equals(state.flag)) {
try {
//如果在车站外,就不用出站,等待,释放锁
state.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("出站");
state.flag = "车站外";
//唤醒state等待进的程
state.notify();
}
}
}
}
}
6. wait与sleep区别
对于sleep()方法,首先要知道该方法是属于Thread类中的, 而wait()方法,则是属于Object类中的
sleep()方法导致了程序暂停执行指定的时间,让出cup该其他线程,但是他的监控状态依然保持者, 当指定的时间到了又会自动恢复运行状态
wait()是把控制权交出去,然后进入等待此对象的等待锁定池处于等待状态,只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态.
在调用sleep()方法的过程中, 线程不会释放对象锁,而当调用wait()方法得时候,线程会放弃对象锁.
当我们要指定唤醒的时候使用sleep
当我们需要指定条件唤醒的时候使用wait
7. synchronized实现可见性的过程
- 获得互斥锁（同步获取锁）
- 清空本地内存
- 从主内存拷贝变量的最新副本到本地内存
- 执行代码
- 将更改后的共享变量的值刷新到主内存
- 释放互斥锁
JUC多线程(三天) 第二天
1. synchronized和volatile(推荐使用)比较
- volatile不需要加锁(使用的是内存屏障,实现内存可见性和重排序的问题), 比synchronize(互斥锁)更轻便, 不会阻塞线程
- synchronized(是重量级的锁)既能保存可见性,又能保证原子性和有序性, 而volatile只能保证可见性和有序性, 无法保证原子性.
- 总结: 与锁相比, volatile变量是一种非常简单但同时又非常脆弱的同步机制, 它在某些情况下将提供优于锁的性能和伸缩性, 如果严格遵循volatile的使用条件(变量正真独立于其他变量和自己以前的值)在某些情况下可以使用volatile代替synchronized来优化代码提升效率.
2. J.U.C 既java.util.concurrent, 是JSR 166标准规范的一个实现; JSR 166以及J.U.C包的作者是Doug Lea.
3. ReentrantLock与synchronized的区别
前面提到ReentrantLock提供了比synchronized更加灵活和强大的锁机制，那么它
的灵活和强大之处在哪里呢？他们之间又有什么相异之处呢？
- 与synchronized相比，ReentrantLock提供了更多，更加全面的功能，具备更强的扩
展性。例如：时间锁等候，可中断锁等候，锁投票。
- ReentrantLock还提供了条件Condition，对线程的等待、唤醒操作更加详细和灵
活，所以在多个条件变量和高度竞争锁的地方，ReentrantLock更加适合（以后会阐
述Condition）。
- ReentrantLock提供了可轮询的锁请求。它会尝试着去获取锁，如果成功则继续，否
则可以等到下次运行时处理，而synchronized则一旦进入锁请求要么成功要么阻
塞，所以相比synchronized而言，ReentrantLock会不容易产生死锁些。
- ReentrantLock支持更加灵活的同步代码块，但是使用synchronized时，只能在同一
个synchronized块结构中获取和释放。注：ReentrantLock的锁释放一定要在finally
中处理，否则可能会产生严重的后果。
- ReentrantLock支持中断处理，且性能较synchronized会好些。
JUC多线程(三天) 第三天
1. 并发容器
HashMap是我们用得非常频繁的一个集合，但是它是线程不安全的。并且在多线程 环境下，put操作是有可能产生死循环，不过在JDK1.8的版本中更换了数据插入的序， 已经解决了这个问题.Java8 对 HashMap 进行了一些修改，最大的不同就是利用了红黑树，所以其由 数组+链表+红黑树 组成。在 Java8 中，当链表中的元素超过了 8 个以后，会将链表 转换为红黑树，在这些位置进行查找的时候可以降低时间复杂度。 jdk7 中使用 Entry 来代表每个 HashMap 中的数据节点，jdk8 中使用 Node，基本没有区别，都是 key，value，hash 和 next 这四个属性，不过，Node 只能用于链表的情况，红黑树的情况需要使用 TreeNode。
put过程
和jdk7的put差不多
- 和 Jdk7 不一样的地方就是，jdk7是先扩容后插入新值的，jdk8 先插值再扩容
- 先使用链表进行存放数据，当数量超过8个的时候，将链表转为红黑树
get 过程分析
-
计算 key 的 hash 值，根据 hash 值找到对应数组下标。
-
判断数组该位置处的元素是否刚好就是我们要找的，如果不是，走第三步。
-
判断该元素类型是否是 TreeNode，如果是，用红黑树的方法取数据，如果不是，走第四步。
-
遍历链表，直到找到相等(==或equals)的 key。
为了解决该问题，提供了Hashtable和Collections.synchronizedMap(hashMap)两种解决方案，但是这两种方案都是对读写加锁，独占式。一个线程在读时其他线程必须等待，吞吐量较低，性能较为低下。而J.U.C给我们提供了高性能的线程安全HashMap： ConcurrentHashMap。
在1.8版本以前，ConcurrentHashMap采用分段锁的概念，使锁更加细化，但是1.8已经改变了这种思路，而是利用CAS+Synchronized来保证并发更新的安全，当然底层采 用数组+链表+红黑树的存储结构。
1. 使用场景
ConcurrentHashMap通常只被看做并发效率更高的Map，用来替换其他线程安全的
Map容器，比如Hashtable和Collections.synchronizedMap。线程安全的容器，特别是
Map，很多情况下一个业务中涉及容器的操作有多个，即复合操作，而在并发执行时，
线程安全的容器只能保证自身的数据不被破坏，和数据在多个线程间是可见的，但无法
保证业务的行为是否正确。
2.ConcurrentHashMap总结：
-
HashMap是线程不安全的，ConcurrentHashMap是线程安全的，但是线程安全仅
仅指的是对容器操作的时候是线程安全的 -
ConcurrentHashMap的public V get(Object key)不涉及到锁，也就是说获得对象时
没有使用锁 -
put、remove方法，在jdk7使用锁，但多线程中并不一定有锁争用，原因在于ConcurrentHashMap将缓存的变量分到多个Segment，每个Segment上有一个锁，只要多个线程访问的不是一个Segment就没有锁争用，就没有堵塞，各线程用各自的锁ConcurrentHashMap缺省情况下生成16个Segment，也就是允许16个线程并发的更新而尽量没有锁争用。而在jdk8中使用的CAS+Synchronized来保证线程安全，比加锁的性能更高
-
ConcurrentHashMap线程安全的，允许一边更新、一边遍历，也就是说在对象遍历
的时候，也可以进行remove,put操作，且遍历的数据会随着remove,put操作产出变
化，
扫一扫
1074
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
