Java进阶---并发编程

一.线程复习

1.什么是线程，进程

进程是操作系统分配资源的基本单位

线程是进程中的一个执行单元(一个独立执行的任务)，是cpu执行的最小单元

2.Java中如何创建线程

1.继承Thread类，重写run()，直接创建子类的对象

2.类实现Runnable接口，重写run()，  任务类   new Thread(任务类对象)

3.类实现Callable接口

4.线程池

3.线程中常用的方法

run()   call()

Thread类中的方法：

        start()；启动线程的，把线程注册到操作系统private native void start0()；

        sleep()；让线程休眠指定的时间

        join()；让其他线程等待当前线程执行完成后再执行

        yeild()；线程礼让

        setDaemon()；设置线程为守护线程

        currentThread()；获得当前正在执行的线程

        wait()；让线程等待，只能被其他线程唤醒

        notify()；notifyAll()；唤醒被wait等待的线程

4.线程的状态

5.多线程

(1)什么是多线程

在程序中(进程)可以创建多个线程来分别执行不同的任务

(2)多线程优缺点

优点：可以提高程序执行效率

缺点：线程多了,需要操作系统进行管理的,占用开销的(不是啥事情都创建线程执行的.)

           多个线程同时访问共享资源(数据)会出现问题

(3)线程同步

加锁排队 (饭堂买饭 排队+加锁 一次只能有一个买饭)

synchronized关键字：

   synchronized修饰方法 非静态方法锁对象是this 静态方法是类的Class对象

   synchronized修饰代码块

ReentrantLock

public class ReentrantLockDemo  implements  Runnable{int num = 10;/*ReentrantLock是java.util.concurrent.locks包下的类,是java代码实现的一种锁控制只能手动的加锁和手动的释放锁只能对某段代码块加锁,不能给整个方法加法*/ReentrantLock reentrantLock = new ReentrantLock();@Overridepublic void run() {while (true){try { reentrantLock.lock();//加锁   if (num > 0) {System.out.println(Thread.currentThread().getName() + "买到第" + num + "张票");num--;} else {break;}}finally {reentrantLock.unlock();//释放锁}}}
}

(4)死锁

多个线程相互持有对方需要的锁对象不释放,二形成的一种相互等待获取锁的现象,

死锁发生后,程序不会报错,只能相互等待,不继续向后执行了.

如何避免死锁发生：

        避免锁的嵌套使用

        避免多个同步代码块中的锁相互使用

口语描述死锁：

       线上1和线程2 同时访问两个代码块, 线程1访问的同步代码块使用A锁,在A锁的同步代码块又使

用了B锁.  

        线程2在访问的同步代码块中使用B锁,在B锁的同步代码块中又用到了A锁,有可能形成死锁.

(5)线程通信(生产者，消费者模型)

在线程同步的基础上进行的,两个线程相互牵制执行

wait(); 线程等待

notify(); 唤醒等待的线程

只能在同步代码块(同步方法)中使用, 还只能通过同步锁对象调用

案例:交替打印数字

public class PrintNum  implements  Runnable{int num = 0;Object obj = new Object();@Overridepublic void run() {while (true){synchronized(obj){obj.notify();System.out.println(Thread.currentThread().getName()+":"+num++);try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}try {obj.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}}}
}

wait()和sleep()区别:

        所属的类不同: wait()属于Object类 sleep()属于Thread类

        阻塞后唤醒方式不同: wait()让线程等待后,需要让另一个线程通过notify()唤醒,如果不唤醒一直

等待

                                           sleep()休眠执定的时间,时间到了后,自动唤醒

        释放锁不同: sleep()不会释放锁

                            wait()会释放锁

二.线程进阶---并发编程

后面谈论的线程内容,几乎都是在多线程对同一共享数据操作的基础上进行.

1.多线程优缺点

优点: 可以提高程序执行效率

缺点: 线程多了,需要操作系统进行管理的,占用开销的(不是啥事情都创建线程执行的.)

         多个线程同时访问共享资源(数据)会出现问题

并发(高并发): 计算机领域指的是同一时刻只能有一个任务执行,多个任务依次执行

                       汉语并发指的是同时执行

并发执行: 在很多用户同时访问时,应当让多个用户并发执行(一个时间段内依次执行)

并行执行: 在同一个时间点上,多个任务同时执行

2.并发编程核心问题

        多个线程同时对同一个资源访问的情况下. 为什么会出现问题.

(1)不可见性

        首先了解java程序运行的内存模型(JMM)

        java在线程操作时,先把主内存中的数据加载到线程的工作内存中,然后对数据进行操作, 但是

线程A在自己的工作内存中操作玩出,线程B不知道,做了同样的操作,最终结果和预期结果不一样

(2)乱序性(无序性)重排序

系统为了优化,在执行某些指令时,会将一些看起来没关系的指令执行顺序改变,但是在,某些情况下会

产生问题.

1    int a = 10;

2    int  b =  从数据库读取

3    int c = a+b;

(3)非原子性

i++;在多线程情况下时线程安全的吗?

i++高级语言,在底层执行时,会被分为3条件

加载i

i+1

i=2

线程的切换执行会带来原子性问题

java内存模型为每个线程提供工作内存(缓存),导致不可见性问题

系统指令优化会把一些指令顺序重排序(在执行一些较为耗时的指令时,把一些其他指令先行执行)，

可能导致程序无法正常执行

线程切换执行会打破指令执行的原子性 ,例如++操作 分为三条指令, 但是在执行这3条指令时,cpu可

能在执行时,切换到其他线程执行,打破原子性执行.

(4)如何解决以上3个问题：

volatile

volatile关键可以解决不可见性和乱序性

**volatile**修饰的共享变量,在被一个线程操作后,可以做到立即对其他线程可见 (volatile底层

实现内存屏障)

volatile修饰的变量禁止对其的执行顺序重排序

volatile只能解决不可见性和重排序问题, 不能解决非原子性问题

(5)如何解决非原子性问题：

        1.加锁(ReentrantLock和synchronized)

        2.使用原子类来解决++在多线程中非原子性问题

AtomicInteger 是一个原子类,能够在不加锁的情况下,实现多线程++操作不出问题,结果正确

private  static AtomicInteger atomicInteger = new AtomicInteger(0);atomicInteger.incrementAndGet();  自增并获得

CAS 机制

CAS(Compare-And-Swap) ：比较并交换

特点: 不加锁实现对变量++操作保证原子性.

优点: 线程不会进入到阻塞状态,一直自旋,效率高

缺点: 线程一直自旋,对cpu开销大, 所以原子类适用于线程少的情况

3.Java中的锁分类

(1)乐观锁/悲观锁

乐观锁: 就是没有加锁的实现. AtomicInteger中的实现就是不加锁的,通过自旋比较实现(CAS)

悲观锁: 就是加锁的实现,认为不加锁是会出问题的 ,ReentrantLock和synchronized都是悲观锁

(2)可重入锁

ReentrantLock和synchronized都是可重入锁

可重入锁又名递归锁, 指的是一个线程在外层方法获得锁时,可以直接进入到内层的加锁的方法中.

(3)自旋锁

指的是对synchronized获得锁的一种描述(特点), 线程在获得锁时,是自旋的不断尝试去获得锁

(4)公平锁/非公平锁

公平锁: 就是排队获得锁,有先来后到 ReentrantLock 既可以是公平锁也可以是非公平锁

非公平锁: 就是抢锁,谁抢到谁执行, 有可能后来的线程先抢到锁 synchronized ReentrantLock

(5)读写锁

ReentrantReadWriteLock

特点: 读读不互斥, 读写互斥, 写写互斥

适合读(查询)多,写少的场景, 提高读的效率

(6)共享锁和独占锁

独占锁: synchronized ReentrantLock都是独占锁,就是有我没他,一次只能有一个线程执行.

共享锁: 一个锁可以被多个线程持有, 读写锁中的读锁就是共享锁

4.synchronized锁的实现

jdk1.7之后,对synchronized锁进行了优化(jdk7之前synchronized锁没有状态,都是自旋的获取锁),

jdk7之后为synchronized锁设计了不同的状态.

无锁状态: 没有线程进入到同步代码块就是无锁状态

偏向锁状态: 只有一个线程访问同步代码块时,同步锁中记录线程id,下次线程访问时,可以快速的获

得锁.

轻量级锁状态: 当线程数量大于1个之后,锁状态由偏向锁升级为轻量级锁, 线程不会阻塞,以自旋方

式获得锁,提高获取锁的效率.

重量级锁状态: 当锁状态为轻量锁时,如果线程自旋到一定次数还获取不到锁,那么锁会升级为重量级

锁,让获取不到锁的线程进入到阻塞状态,等待操作系统调度.

使用synchronized锁的时候，必须为锁提供一个同步锁对象的，此对象就是用来记录锁状态的

对象中有一个区域叫对象头，对象头中中有一块区域叫mark word，记录对象运行时的一些数据，

如锁状态，哈希值，GC分代年龄，当前线程id.

synchronized时java中内置的一种的锁，底层实现是靠底层指令进行控制的，

使用时必须提供一个同步锁对象,用来记录锁的各种状态.

5.AQS

AbstractQueuedSynchronizer 抽象同步队列, 并发包下面很多类的底层实现都会用到

内部有一个int类的变量state,用来记录有没有线程使用

内部会构建一个队列,用来存储没有获得锁的线程

6.ReentrantLock锁实现

ReentrantLock 基于 AQS的,

ReentrantLock 可以实现公平锁和非公平锁

内部结构

公平和非公平的区别

三.Java集合类复习

javaSE中3个重点: 面向对象相关知识

                              集合类 (数据结构,线程)

                              多线程

次重点: 网络 (计网)

             IO

             常用类

             异常

单列集合 Collection

       List

                ArrayList 底层数组实现 查询块

                LinkedList   底层链表   查询慢

                Vector 底层也是数组,是线程安全的

        Set

                HashSet

                TreeSet

双列集合 Map

        HashMap

        TreeMap

        Hashtable

1.你能讲一下HashMap吗？

基本特点: 双列集合,键不能重复,值可以重复,可以有一个key为null

数据结构:

源码

put方法源码分析

public V put(K key, V value) {//通过key计算哈希值return putVal(hash(key), key, value, false, true);
}

static final int hash(Object key) {int h;                       为了减少哈希值冲突return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {Node<K,V>[] tab; //哈希表Node<K,V> p; //记录之前int n, i; //n是哈希表长度, i是索引if ((tab = table) == null || (n = tab.length) == 0)n = (tab = resize()).length;//创建哈希表if ((p = tab[i = (n - 1) & hash]) == null) // == 97%16 根据哈希值计算位置//如果该位置为null,则直接将key,value包装到一个node对象中,直接存放到第i个位的第一个tab[i] = newNode(hash, key, value, null);else {Node<K,V> e; K k;//判断key是否重复, 先判断哈希值(快),但是哈希有问题,值相同,但内容不同,//所以在哈希值相同时,需要调用equals(),判断内容是否相同.if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))e = p;//当key不重复时,判断类型是树类型还是链表类型else if (p instanceof TreeNode)//已经是树类型,向红黑树上添加元素e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);else {//链表for (int binCount = 0; ; ++binCount) {if ((e = p.next) == null) {p.next = newNode(hash, key, value, null);//添加完成后,判断链表长度if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1sttreeifyBin(tab, hash);//转红黑树break;}if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))break;p = e;}}if (e != null) { // existing mapping for keyV oldValue = e.value;if (!onlyIfAbsent || oldValue == null)e.value = value;//key相同时,会用后面key的值,覆盖之前的相同的key的值afterNodeAccess(e);return oldValue;}}++modCount;if (++size > threshold)resize();afterNodeInsertion(evict);return null;}

重点参数:

1.哈希表长度: 默认是16

2.哈希表每次扩容原来 2 倍

3.哈希表的负载因子 0.75, 哈希表不会装满的,装满会影响查询效率,所以会牺牲一定的空间而换取查询效率

4.链表长度上限是 8 ,尝试将链表转为红黑树,但是不一定转成功, 还会判断哈希表长度,哈希表长度小于64 会先扩容哈希表,扩容后所有元素位置需要重新计算,这样链表会变短, 只有当链表长度大于等于8且哈希表长度大于64,链表才会转成红黑树.

5.当红黑树节点数量减少为6个时,红黑树退化成链表

2.ConcurrentHashMap

ConcurrentHashMap是一个线程安全的map,加锁的方式与Hashtable不同

Hashtable直接在方法上加锁,一次只能有一个线程进入方法操作.

ConcurrentHashMap不是给方法加的锁,个每个哈希表中的位置加锁