多线程的基础补充

最新推荐文章于 2024-03-07 22:51:47 发布

罗隽_jerChuan

最新推荐文章于 2024-03-07 22:51:47 发布

阅读量471

点赞数

分类专栏：线程池文章标签： java 多线程

本文链接：https://blog.csdn.net/qq_31678809/article/details/114070755

版权

线程池专栏收录该内容

3 篇文章 0 订阅

订阅专栏

7.sycronized和lock锁的区别

8.生产者和消费者问题

9.8锁现象

什么是JUC java.util.concurrent

1.业务：普通的线程代码 Thread

Runnable 没有返回值，效率相比于Callable较低

2.进程和线程

进程：一个程序

一个进程包含多个线程，至少一个

java至少两个线程，一个main方法，一个gc线程

java真的可以开启线程么：不能，最后是通过本地方法通过操作系统运行线程

public synchronized void start() {
    /**
     * This method is not invoked for the main method thread or "system"
     * group threads created/set up by the VM. Any new functionality added
     * to this method in the future may have to also be added to the VM.
     *
     * A zero status value corresponds to state "NEW".
     */
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    /* Notify the group that this thread is about to be started
     * so that it can be added to the group's list of threads
     * and the group's unstarted count can be decremented. */
    group.add(this);

    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}

private native void start0();

3.并发与并行

并发：多个线程操作同一个资源是cpu单核的情况下，快速交替运行

并行：多个资源一起行走在cpu多核的同时执行

package com.gupao.juc; public class test1 { public static void main(String[] args) { //获取cpu的核数 System.out.println(Runtime.getRuntime().availableProcessors()); } }

并发编程的本质：充分利用cpu资源

4.线程有几个状态

创建就绪运行阻塞结束销毁

5.sleep和wait的区别

sleep->thread

wait->object

wait释放锁，sleep不会释放锁

范围不同，wait必须在同步代码块中，sleep可以在任何地方

6.lock锁

传统syncronized自动释放锁

lock锁需要手动加锁释放锁三部曲：new ReentantLock();Lock.lock() Lock.unLock()

lock锁相对于syncronized效率更高，并且并发编程通用lock锁，并且扩展度更高。

lock接口

ReentrantLock

公平锁：十分公平，可以先来后到

非公平锁：十分不公平，可以插队(默认)

7.sycronized和lock锁的区别

1.sycronized是关键字，lock锁是类

2.无法判断锁的状态，lock可以判断是否取到锁

3.sycronized自动释放锁，lock锁必须手动释放

4.sycronized线程1（获得锁），线程2（等待） lock锁就不一定会等待下去 lock.trylock()能够尝试去获取锁

5.sycronized 可重入锁，不可中断的非公平 lock锁可重入锁，可中断锁，非公平（可以自己设置）

6.sycronized适合锁少量的代码同步问题，lock适合锁大量的代码同步

8.生产者和消费者问题

sycronized版本 wait notify（虚假唤醒）

如下版本1，其中的消费者和生产者的等待和唤醒只能针对2个线程的情况，如果存在2个以上的线程，当唤醒时，可能会有多个线程争抢资源，此时导致虚假唤醒的隐患。

那么我们要解决虚假唤醒则需要通过将等待唤醒放置在循环中，既将if修改为while

结果：

juc版本

我们可以看到 syncronized版本无法去指定0，1，2，3线程按顺序执行，他们是自行唤醒去争抢锁资源的 juc为我们提供了新的方式。

首先，Lock接口为我们提供了新的等待和唤醒方法，它就是condition接口中的await和signel

以这种方式实现的效果和syncronized的等待和唤醒是同一效果。

condition实现精准通知唤醒

通过自己本身的condition，来控制线程的唤醒，达到精确唤醒的效果

package com.gupao.juc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class C {
    public static void main(String[] args) {
        data3 data3 = new data3();
        new Thread(()->{data3.printA();},"A").start();
        new Thread(()->{data3.printB();},"B").start();
        new Thread(()->{data3.printC();},"C").start();
    }

}
class data3{
    private Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    private int number = 1;
    public void printA(){
        lock.lock();
        try{
            while(number!=1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName());
            number++;
            condition2.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try{
            while(number!=2){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName());
            number++;
            condition3.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try{
            while(number!=3){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName());
            number = 1;
            condition1.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}