多线程03

最新推荐文章于 2024-11-01 14:48:20 发布

好好编程不会胖！

最新推荐文章于 2024-11-01 14:48:20 发布

阅读量85

点赞数

文章标签： java

本文链接：https://blog.csdn.net/m0_56161569/article/details/120165591

版权

一.线程同步

1.线程同步

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时,也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机synchronized,当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题:
1.一个线程持有锁会导致其他所有需要此锁的线程挂起;
2.在多线程竞争下,加锁，释放锁会导致比较多的上下文切换和调度延时,引起性能问题;
3.如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题。
2.同步方法
由于我们可以通过private 关键字来保证数据对象只能被方法访问，所以我们只需
要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法︰synchronized方法和synchronized块
同步方法: public synchronized void method(int args){ }
synchronized方法控制对“对象”的访问，每个对象对应一把锁,每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。
缺陷 : 若将一个大的方法申明为synchronized将会影响效率
3.同步方法弊端
方法里面需要修改的内容才需要锁，锁的太多,浪费资源
4.同步块
同步块: synchronized (Obj){ }
Obj称之为同步监视器
◆Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
◆同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this ,就是
这个对象本身,或者是class [反射中讲解]
同步监视器的执行过程
1.第一个线程访问，锁定同步监视器，执行其中代码.
2.第二个线程访问，发现同步监视器被锁定，无法访问.
3.第一个线程访问完毕，解锁同步监视器
4.第二个线程访问，发现同步监视器没有锁，然后锁定并访问

二.死锁

1.死锁

多个线程各自占有一-些共享资源 ,并且互相等待其他线程占有的资源才能运行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形.。某一个同步块
同时拥有“两个以上对象的锁”时,就可能会发生“死锁”的问题。

2.死锁避免方法

产生死锁的四个必要条件:
1.互斥条件: 一个资源每次只能被一一个进程使用。
2.请求与保持条件: 一个进程因请求资源而阻塞时，对已获得的资源保持不放。
3.不剥夺条件 : 进程已获得的资源，在末使用完之前，不能强行剥夺。
4.循环等待条件 : 若干进程之间形成一种头尾相接的循环等待资源关系。
上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件
就可以避免死锁发生。

3.Lock锁

从JDK 5.0开始，Java提供了更强大的线程同步机制一通过显式定义同步锁对
象来实现同步。同步锁使用L ock对象充当。
java.util.concurrent.locks.L ock接口是控制多个线程对共享资源进行访问的工具。
锁提供了对共享资源的独占访问，每次只能有一-个线程对Lock对象加锁，线程开
始访问共享资源之前应先获得Lock对象。
ReentrantLock 类实现了Lock，它拥有与synchronized相同的并发性和内存语
义，在实现线程安全的控制中，比较常用的是ReentrantLock,可以显式加锁、释
放锁。

class A{
    private final ReentrantLock lock=new ReentrantLock();
    public void m(){
        lock.lock();
        try {
               //保证线程安全的代码;
        }
        finally {
            lock.unlock();
            //如果同步代码有异常，要将unlock()写入finally语句块
        }
    }
}

4.synchronized与Lock的对比

Lock是显式锁(手动开启和关闭锁，别忘记关闭锁) synchronized是隐式锁，出了
作用域自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用L ock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)
优先使用顺序 :
◆Lock >同步代码块(已经进入了方法体，分配了相应资源) >同步方法(在方法体之外)

三.线程通信(生产者消费者模式)

1.应用场景: 生产者和消费者问题

假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库﹐消费者将仓库中产品取走消费。
如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止。
如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。

这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。
对于生产者，没有生产产品之前，要通知消费者等待。而生产了产品之后，又需要马上通知消费者消费
对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费。
在生产者消费者问题中，仅有synchronized是不够的
synchronized可阻止并发更新同一个共享资源，实现了同步
synchronized 不能用来实现不同线程之间的消息传递(通信)
2.解决线程之间的通信问题的方法
wait() : 表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
wait(long timeout) : 指定等待的毫秒数
notify() : 唤醒一个处于等待状态的线程
notifyAll() : 唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度
注意 : 均是Object类的方法,都只能在同步方法或者同步代码块中使用,否则会抛出异常lllegalMonitorStateException。

解决方式1
并发协作模型“生产者/消费者模式”—>管程法

生产者∶负责生产数据的模块(可能是方法﹐对象,线程,进程)；
消费者:负责处理数据的模块(可能是方法﹐对象，线程,进程)；
缓冲区:消费者不能直接使用生产者的数据﹐他们之间有个“缓冲区
生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据

解决方式2

并发协作模型“生产者/消费者模式”—>信号灯法

四.线程池

1.使用线程池

背景:经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路:提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处:
1.提高响应速度（减少了创建新线程的时间)
2.降低资源消耗（重复利用线程池中线程，不需要每次都创建)
3.便于线程管理(…)
corePoolSize : 核心池的大小
maximumPoolSize : 最大线程数
keepAliveTime : 线程没有任务时最多保持多长时间后会终止
JDK 5.0起提供了线程池相关APl: ExecutorService和Executors
ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
1.void execute(Runnable command)∶执行任务/命令，没有返回值，一般用来执行Runnable
2. Future submit(Callable task):执行任务，有返回值，一般又来执行Callable
3.void shutdown():关闭连接池
Executors:工具类、线程池的工厂类，用于创建并返回不同类型的线程池

多线程总结:

package thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//线程的创建
public class ThreadNew {

    public static void main(String[] args) {
        new MyThread1().start();

        new Thread(new MyThread2()).start();

        FutureTask<Integer> futureTask=new FutureTask<Integer>(new MyThread3());
        new Thread(futureTask).start();

        try {
            Integer integer= futureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

//1.继承Thread类
class MyThread1 extends Thread{
    @Override
    public void run() {
        System.out.println("MyThread1");
    }
}

//2.实现Runnable接口
class MyThread2 implements Runnable{
    @Override
    public void run() {
        System.out.println("MyThread2");
    }
}

//3.实现Callable接口
class MyThread3 implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        return 100;
    }
}