多线程高并发,这一篇你就进阶了

最新推荐文章于 2024-04-28 09:44:26 发布

hotcsawp

最新推荐文章于 2024-04-28 09:44:26 发布

阅读量1.1k

点赞数

文章标签： java 开发语言数据结构

本文链接：https://blog.csdn.net/hotcsawp/article/details/124830770

版权

多线程

多线程实现方式

启动线程的只有一个，代理模式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(