多线程
多线程实现方式
启动线程的只有一个,代理模式Thread(proxy).start();
Runnable和Callable只能以实例的形式被代理启动线程。
1.Thread类
override run();
//运行 .start()
2.Runnable接口
没有返回值,不会抛出异常
override run();
//运行 需要代理类对象运行 new Thread(实现类).start
3.Callable接口
类似于Runnable,都是为其实例可能有另一个线程执行的类设计的
有返回值,会抛出异常
override call();
return
//运行方式1
public interface RunnableFuture<V> extends Runnable, Future<V> {
/**
* Sets this Future to the result of its computation
* unless it has been cancelled.
*/
void run();
}
public class FutureTask<V> implements RunnableFuture<V>
public FutureTask(Callable<V> callable)
new Thread(new Runnable()).start();
new Thread(new FutureTask<V>(),"A").start();//
new Thread(new FutureTask<V>(),"B").start();//有缓存,只执行1次call(),
futureTask .get();//可能会产生阻塞,放到代码最后,或者使用异步通信处理,跑完之后在拿结果
new Thread(new FutureTask<V>(Callable).start();
FutureTask futureTask = new FutureTask(Callable callable);
FutureTask继承了Runnable接口,运行需要代理类对象运行 new Thread(实现类).start
//运行方式2
executorService.submit((Callable callable);
线程状态
5个:1.新生状态 2.就绪状态 3.运行状态 4.阻塞状态 5.死亡状态
线程停止
不建议使用jdk提供的stop(),destory(),已废弃,使用标识控制线程停止
线程休眠sleep()
线程阻塞,参数时间,存在异常需要捕获,休眠后会进入就绪状态,每一个对象都有一个锁,sleep不会释放锁
线程礼让yield()
当前正在执行的线程暂停,线程从运行状态转为就绪状态,不阻塞,也不一定礼让成功
合并线程Join()
插队的意思,当前线程阻塞,执行其他线程,其他线程执行完后在执行当前线程
线程状态getState()
枚举类型,有6个
线程的优先级get/setPriority()
不一定成功,但是会增加成功的权重
守护线程setDaemon()
线程分为用户线程和守护线程,虚拟机必须确保用户线程执行完毕,而守护线程不需要等待执行完毕
线程同步机制
多个线程操作同一个数据的时候在同一时刻会产生并发,需要同步,最可靠的保证办法就是同步(排队),此时这些线程就进入对象的等待池,形成队列,排队执行
每个对象都有一把锁,这个锁就是在线程同步时候使用,线程同步形成的条件 :队列+锁
为了保证数据的安全性使用锁,synchronized,排他锁,独占资源,其他线程必须等待,所以也存在一些问题
1.其他需要此锁的线程挂起等待,效率变低
2.在多线程竞争下,加锁、释放锁会导致比较多的上下文切换和调度延时,必然会损失性能
3.优先级高的线程等待优先级低的线程释放锁,会引起优先级倒置,引起性能问题(重要):比如说Thread A run()10H,Thread B run()1S
B要等待10小时
死锁
多个线程相互持有对方需要的资源,形成僵持
形成条件(4个同时满足)
互斥,一个资源每次只能被一个进程使用
线程协作(通信)
1.一个进程内的两个线程
2.两个进程的两个线程
1.生产者消费者管程法
2。生产者消费者信号灯法
注意,2个以上线程唤醒存在虚假唤醒,if改为while循环判断
实现方式1.管程法
信号灯法(flag)
ThreadLocal
将数据缓存在线程内的线程本地存储机制,该线程可在生命周期内任意方法中缓存或获取缓存的数据
底层使用ThreadLocalMap实现,是Thread的局部变量,数据结构ThreadLocalMap<ThreadLocal,value>
如果在线程池中使用ThreadLocal会造成内存泄漏,因为线程执行任务后不会被回收而是执行下一个任务,缓存的变量一直存在,用完后需要手动move()掉
应用场景:链接管理,一个线程持有一个链接,该链接对象可以在不同方法间传递
JUC
package java.util.concurrent;//juc,并发包
package java.util.concurrent.atomic;//原子性
package java.util.concurrent.locks;//Lock锁
package java.util.function;//函数式
降低耦合性,多线程尽量不用以前的implements Runnable实现,oop思想,抽象成一个资源类来操作
锁
Lock
实现类有3个
常用实现类ReentrantLock.
和Condition组合使用
public class ReentrantLock implements Lock, java.io.Serializable//可重用锁,常用
//Constructors
public ReentrantLock() {
sync = new NonfairSync();//非公平锁
}
//Constructors
public ReentrantLock(boolean fair) {//FairSync公平锁
sync = fair ? new FairSync() : new NonfairSync();
}
/**
公平锁:先来后到 非公平锁:可以插队(默认),synchronized是非公平锁
/**
private final ReentrantReadWriteLock.ReadLock readerLock;//读锁
private final ReentrantReadWriteLock.WriteLock writerLock;//写锁
ReadWriteLock
读写锁
独占锁:一次只能被一个线程占有 共享锁:一次可以被多个线程占有
ReadWriteLock维护一对关联的locks ,一个用于只读操作,一个用于写入。只要没有写者, read lock可能被多个读线程同时持有。 write lock是独占的,即:写是一个线程写,读可以多个线程读
实现类
public class ReentrantReadWriteLock
implements ReadWriteLock, java.io.Serializable {
/**
* demo
*/
import java.util.HashMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteLockDemo {
public static void main(String[] args) {
MyCache cache = new MyCache();
ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
/**
* 写
*/
for (int i = 0; i < 5; i++) {
final int temp = i;
new Thread(()->{
try {
readWriteLock.writeLock().lock();//并发写入,原子性操作,需要加锁
System.out.println("开始写入缓存:"+temp+"...");
cache.set(temp+"",Integer.valueOf(temp));
}finally {
readWriteLock.writeLock().unlock();
}
},Thread.currentThread().getName()).start();
}
/**
* 读
*/
for (int i = 0; i < 6; i++) {
final int temp = i;
new Thread(()->{
System.out.println("从缓存中取出数据"+cache.get(temp+""));
}).start();
}
}
}
class MyCache{
private volatile HashMap<String, Object> cache = new HashMap<String, Object>();
public void set(String key,Object Value){
cache.put(key,Value);
System.out.println(key+"已放入缓存...");
}
public Object get(String key){
return key == null ? null : cache.get(key);
}
}
开始写入缓存:1...
1已放入缓存... // 写是原子性操作
开始写入缓存:0...
0已放入缓存...
开始写入缓存:2...
2已放入缓存...
开始写入缓存:3...
3已放入缓存...
开始写入缓存:4...
4已放入缓存...
从缓存中取出数据0
从缓存中取出数据1
从缓存中取出数据2
从缓存中取出数据4
从缓存中取出数据null
从缓存中取出数据3
synchronized和lock对比
1.synchronized是内置关键字,Lock是一个接口
2.synchronized无法获取锁状态,Lock可以判断是否获得锁
3.synchronized隐式锁(出了作用域自动释放),lock显示锁(手动加锁解锁),不释放会产生死锁
4.synchronized如果有两个线程,并且线程B等待线程A,如果A阻塞,B就一直等待,Lock有thyLock()不一定一直等待
5.synchronized 可重入锁,不可中断,非公平锁,Lock可重入锁,可以判断锁,可以指定公平或非公平锁
6.Lock只有代码块锁,synchorized还有方法锁
7.Lock锁,JVM话费较少的时间来调度线程,性能好,有扩展性(提供更多子类)
8.可重入锁中,synchronized 只有一把锁,Lock有两把
可重入锁
锁中锁,也叫递归锁
/**
* 可重入锁:锁中锁.synchronized的demo
* A.lock会自动带入到B中,只有一把锁,B会阻塞
*/
public class RTTLockDemo {
public static void main(String[] args) {
Person person = new Person();
new Thread(()->{
person.eat();
},"A").start();
new Thread(()->{
person.eat();
},"B").start();
}
}
class Person{
public synchronized void eat(){
System.out.println(Thread.currentThread().getName()+".eat...");
drink();
}
public synchronized void drink(){
System.out.println(Thread.currentThread().getName()+".drink...");
}
}
A.eat...
A.drink...
B.eat...
B.drink...
/**
* 可重入锁:锁中锁.Lock的demo
* A.lock锁有两对,B会阻塞
*/
public class RTTLockDemo {
public static void main(String[] args) {
Person1 person = new Person1();
new Thread(()->{
person.eat();
},"A").start();
new Thread(()->{
person.eat();
},"B").start();
}
}
class Person1{
Lock lock = new ReentrantLock();
public void eat(){
lock.lock();
try {
System.out.println(Thread.currentThread().getName()+".eat...");
//eat.lock中还有一把drink.lock,
drink();
}finally {
lock.unlock();
}
}
public void drink(){
lock.lock();
try {
System.out.println(Thread.currentThread().getName()+".drink...");
}finally {
lock.unlock();
}
}
}
A.eat...
A.drink...
B.eat...
B.drink...
自旋锁
class MyLock{
public static void main(String[] args) {
SpinLockDemo spinLockDemo = new SpinLockDemo();
new Thread(()->{
spinLockDemo.myLock();
System.out.println(Thread.currentThread().getName()+"线程加锁成功...");
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
spinLockDemo.myUnLock();
System.out.println(Thread.currentThread().getName()+"线程解锁成功...");
},"A").start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
spinLockDemo.myLock();
System.out.println(Thread.currentThread().getName()+"线程加锁成功...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
spinLockDemo.myUnLock();
System.out.println(Thread.currentThread().getName()+"线程解锁成功...");
},"B").start();
}
}
/**
* 自旋锁
*/
public class SpinLockDemo {
AtomicReference<Thread> atomicReference = new AtomicReference<>();
public void myLock(){
System.out.println(Thread.currentThread().getName()+"加锁中...");
//CAS自旋加锁
while (!atomicReference.compareAndSet(null,Thread.currentThread())){
}
}
//解锁
public void myUnLock(){
System.out.println(Thread.currentThread().getName()+"解锁中...");
//CAS解锁
atomicReference.compareAndSet(