【JUC】001-多线程回顾、synchronized与Lock锁

最新推荐文章于 2022-12-06 15:09:23 发布
最新推荐文章于 2022-12-06 15:09:23 发布
阅读量277 收藏
点赞数
分类专栏： JUC 文章标签： 多线程 java 并发编程 多进程 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29689343/article/details/109703644
版权

目录

0、警醒自己

一、什么是JUC

二、进程与线程

1、概述

2、并发编程的目的

3、线程有几个状态

4、wait与sleep的区别

来自不同的类：

关于锁的释放：

释放的范围不同：

是否需要捕获异常：

三、传统加锁synchronized

1、传统的并发卖票问题

代码：

运行结果：

2、传统的解决方式在方法上加synchronized

代码：

运行结果：

四、Lock锁

1、包路径

2、接口的方法

3、实现类

4、使用Lock代替synchronized

代码：

运行结果：

五、synchronized与Lock锁区别

1、区别

2、锁是什么，如何判断锁的是谁（见【JUC】002）

生产者、消费者问题（synchronized版本）：

存在问题（虚假唤醒）：

生产者、消费者问题（Lock版本）：

Condition实现精准等待和通知：

0、警醒自己

1、学习不用心，骗人又骗己；

2、学习不刻苦，纸上画老虎；

3、学习不惜时，终得人耻笑；

4、学习不复习，不如不学习；

5、学习不休息，毁眼伤身体；

7、狗才等着别人喂，狼都是自己寻找食物；

 

一、什么是JUC

 

二、进程与线程

1、概述

见之前的博客：

https://blog.csdn.net/qq_29689343/article/details/95861050

Java默认有两个线程，一个是Main线程，另一个是GC（垃圾回收）线程；

Java开启线程的三种方式：Thread、Runnable、Callable；

Java真的能开启线程吗？不能！

new Thread().start();

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 */
            }
        }
    }
    
    //本地方法，底层调用的c++，java无法操作硬件
    private native void start0();

 

2、并发编程的目的

充分利用CPU资源；

 

3、线程有几个状态

6个；

Thread.State;

    public enum State {
        //新生
        NEW,

        //运行
        RUNNABLE,

        //阻塞
        BLOCKED,

        //等待，死死的等
        WAITING,

        //超时等待，限时等待
        TIMED_WAITING,

        //终止
        TERMINATED;
    }

 

4、wait与sleep的区别

来自不同的类：

wait来自Object；

sleep来自Thread；

 

关于锁的释放：

wait会释放锁，sleep睡眠，抱着锁睡觉了，不会释放锁；

 

释放的范围不同：

wait必须用在同步代码块；

sleep可以在任何地方使用；

 

是否需要捕获异常：

wait不需要，sleep需要；

 

三、传统加锁synchronized

1、传统的并发卖票问题

代码：

package com.zibo;

//买票
//企业开发中，线程是一个单独的资源类，没有任何附属操作
//属性、方法
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        // 并发：多线程同时操作一个资源类，把资源类丢入线程
        Ticket ticket = new Ticket();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        },"C").start();

    }
}
//资源类OOP
class Ticket{
    //属性、方法
    private int num = 50;

    //卖票的方式
    public void sale(){
        if(num>0){
            System.out.println(Thread.currentThread().getName() + "卖出了第" + num-- + "张票，剩余" + num + "张票！");
        }
    }
}

运行结果：

A卖出了第50张票，剩余49张票！
A卖出了第49张票，剩余48张票！
A卖出了第48张票，剩余47张票！
A卖出了第47张票，剩余46张票！
B卖出了第46张票，剩余44张票！
A卖出了第45张票，剩余44张票！
B卖出了第44张票，剩余43张票！
A卖出了第43张票，剩余42张票！
B卖出了第42张票，剩余41张票！
A卖出了第41张票，剩余40张票！
B卖出了第40张票，剩余39张票！
A卖出了第39张票，剩余38张票！
B卖出了第38张票，剩余37张票！
A卖出了第37张票，剩余36张票！
B卖出了第36张票，剩余35张票！
C卖出了第34张票，剩余33张票！
A卖出了第35张票，剩余34张票！
C卖出了第32张票，剩余31张票！
B卖出了第33张票，剩余32张票！
C卖出了第30张票，剩余29张票！
A卖出了第31张票，剩余30张票！
C卖出了第28张票，剩余27张票！
B卖出了第29张票，剩余28张票！
C卖出了第26张票，剩余25张票！
A卖出了第27张票，剩余26张票！
C卖出了第24张票，剩余23张票！
B卖出了第25张票，剩余24张票！
C卖出了第22张票，剩余21张票！
A卖出了第23张票，剩余22张票！
C卖出了第20张票，剩余19张票！
B卖出了第21张票，剩余20张票！
C卖出了第18张票，剩余17张票！
A卖出了第19张票，剩余18张票！
C卖出了第16张票，剩余15张票！
B卖出了第17张票，剩余16张票！
C卖出了第14张票，剩余13张票！
A卖出了第15张票，剩余14张票！
C卖出了第12张票，剩余11张票！
B卖出了第13张票，剩余12张票！
C卖出了第10张票，剩余9张票！
A卖出了第11张票，剩余10张票！
C卖出了第8张票，剩余7张票！
B卖出了第9张票，剩余8张票！
C卖出了第6张票，剩余5张票！
A卖出了第7张票，剩余6张票！
C卖出了第4张票，剩余3张票！
B卖出了第5张票，剩余4张票！
C卖出了第2张票，剩余1张票！
A卖出了第3张票，剩余2张票！
B卖出了第1张票，剩余0张票！

 

2、传统的解决方式在方法上加synchronized

代码：

//卖票的方式
    public synchronized void sale(){
        if(num>0){
            System.out.println(Thread.currentThread().getName() + "卖出了第" + num-- + "张票，剩余" + num + "张票！");
        }
    }

运行结果：

A卖出了第50张票，剩余49张票！
A卖出了第49张票，剩余48张票！
A卖出了第48张票，剩余47张票！
A卖出了第47张票，剩余46张票！
A卖出了第46张票，剩余45张票！
A卖出了第45张票，剩余44张票！
B卖出了第44张票，剩余43张票！
B卖出了第43张票，剩余42张票！
B卖出了第42张票，剩余41张票！
B卖出了第41张票，剩余40张票！
B卖出了第40张票，剩余39张票！
B卖出了第39张票，剩余38张票！
B卖出了第38张票，剩余37张票！
B卖出了第37张票，剩余36张票！
B卖出了第36张票，剩余35张票！
B卖出了第35张票，剩余34张票！
B卖出了第34张票，剩余33张票！
B卖出了第33张票，剩余32张票！
B卖出了第32张票，剩余31张票！
B卖出了第31张票，剩余30张票！
B卖出了第30张票，剩余29张票！
B卖出了第29张票，剩余28张票！
B卖出了第28张票，剩余27张票！
B卖出了第27张票，剩余26张票！
B卖出了第26张票，剩余25张票！
B卖出了第25张票，剩余24张票！
A卖出了第24张票，剩余23张票！
A卖出了第23张票，剩余22张票！
A卖出了第22张票，剩余21张票！
A卖出了第21张票，剩余20张票！
A卖出了第20张票，剩余19张票！
A卖出了第19张票，剩余18张票！
A卖出了第18张票，剩余17张票！
A卖出了第17张票，剩余16张票！
A卖出了第16张票，剩余15张票！
A卖出了第15张票，剩余14张票！
A卖出了第14张票，剩余13张票！
A卖出了第13张票，剩余12张票！
A卖出了第12张票，剩余11张票！
A卖出了第11张票，剩余10张票！
C卖出了第10张票，剩余9张票！
C卖出了第9张票，剩余8张票！
C卖出了第8张票，剩余7张票！
C卖出了第7张票，剩余6张票！
C卖出了第6张票，剩余5张票！
C卖出了第5张票，剩余4张票！
C卖出了第4张票，剩余3张票！
C卖出了第3张票，剩余2张票！
C卖出了第2张票，剩余1张票！
C卖出了第1张票，剩余0张票！

 

四、Lock锁

1、包路径

 

2、接口的方法

 

3、实现类

 

4、使用Lock代替synchronized

Lock lock = new ReentrantLock();

公平锁：十分公平，可以先来后到，按顺序；

非公平锁：可以插队（默认）；

 

代码：

package com.zibo;

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

//买票
//企业开发中，线程是一个单独的资源类，没有任何附属操作
//属性、方法
public class SaleTicketDemo02 {
    public static void main(String[] args) {
        // 并发：多线程同时操作一个资源类，把资源类丢入线程
        Ticket2 ticket = new Ticket2();
        //我们现在不想用synchronized了
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        },"C").start();
    }
}

//资源类OOP
class Ticket2{
    //属性、方法
    private int num = 50;

    Lock lock = new ReentrantLock();

    //卖票的方式
    //使用Lock锁
    public void sale(){
        //加锁
        lock.lock();
        try {
            if(num>0){
                System.out.println(Thread.currentThread().getName() + "卖出了第" + num-- + "张票，剩余" + num + "张票！");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

 

运行结果：

A卖出了第50张票，剩余49张票！
A卖出了第49张票，剩余48张票！
A卖出了第48张票，剩余47张票！
A卖出了第47张票，剩余46张票！
A卖出了第46张票，剩余45张票！
A卖出了第45张票，剩余44张票！
A卖出了第44张票，剩余43张票！
C卖出了第43张票，剩余42张票！
C卖出了第42张票，剩余41张票！
C卖出了第41张票，剩余40张票！
C卖出了第40张票，剩余39张票！
C卖出了第39张票，剩余38张票！
C卖出了第38张票，剩余37张票！
C卖出了第37张票，剩余36张票！
C卖出了第36张票，剩余35张票！
C卖出了第35张票，剩余34张票！
C卖出了第34张票，剩余33张票！
C卖出了第33张票，剩余32张票！
C卖出了第32张票，剩余31张票！
C卖出了第31张票，剩余30张票！
C卖出了第30张票，剩余29张票！
C卖出了第29张票，剩余28张票！
C卖出了第28张票，剩余27张票！
C卖出了第27张票，剩余26张票！
C卖出了第26张票，剩余25张票！
C卖出了第25张票，剩余24张票！
C卖出了第24张票，剩余23张票！
B卖出了第23张票，剩余22张票！
B卖出了第22张票，剩余21张票！
B卖出了第21张票，剩余20张票！
B卖出了第20张票，剩余19张票！
B卖出了第19张票，剩余18张票！
B卖出了第18张票，剩余17张票！
B卖出了第17张票，剩余16张票！
B卖出了第16张票，剩余15张票！
B卖出了第15张票，剩余14张票！
B卖出了第14张票，剩余13张票！
B卖出了第13张票，剩余12张票！
B卖出了第12张票，剩余11张票！
B卖出了第11张票，剩余10张票！
B卖出了第10张票，剩余9张票！
B卖出了第9张票，剩余8张票！
B卖出了第8张票，剩余7张票！
B卖出了第7张票，剩余6张票！
B卖出了第6张票，剩余5张票！
B卖出了第5张票，剩余4张票！
B卖出了第4张票，剩余3张票！
A卖出了第3张票，剩余2张票！
A卖出了第2张票，剩余1张票！
A卖出了第1张票，剩余0张票！

 

五、synchronized与Lock锁区别

1、区别

1、synchronized是内置关键字，Lock是一个接口；

2、synchronized无法判断获取锁的状态，Lock可以判断是否获取到了锁；

3、synchronized是全自动的，自动释放锁，lock锁必须要手动释放锁，否则死锁（自动档、手动档）；

4、synchronized：线程1（获得锁，阻塞）、线程2（傻傻等待）；lock锁：不一定会等下去（尝试获取锁）；

lock锁：lock.tryLock();尝试获取锁；

5、synchronized是可重入锁、不可中断、非公平；lock锁是可重入锁、可以判断、是否公平（可设置）；

6、synchronized适合锁少量代码，Lock适合锁大量的代码；

 

2、锁是什么，如何判断锁的是谁（见【JUC】002）

（面试重点：单例模式、排序算法、生产者和消费者、死锁）

生产者、消费者问题（synchronized版本）：

代码演示：

package com.zibo;

/**
 * 线程之间的通信问题：生产者和消费者问题，等待唤醒，通知唤醒
 * 线程交替执行，A和B操作同一个变量 num=0
 * A num+1
 * B num-1
 */
public class A {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}
//等待、业务、通知
class Data{
    private int num = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        if(num!=0){
            //等待操作
            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName() + "==>" + num);
        //通知其他线程我加完了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        if(num==0){
            //等待操作
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + "==>" + num);
        //通知其他线程我减完了
        this.notifyAll();
    }
}

运行结果：

A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
A==>1
B==>0

 

存在问题（虚假唤醒）：

上面是两个线程，四个线程还安全吗？

运行结果：

A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
C==>1
B==>0
A==>1
B==>0
C==>1
B==>0
A==>1
D==>0
C==>1
B==>0
A==>1
D==>0
C==>1
B==>0
A==>1
D==>0
C==>1
D==>0
A==>1
D==>0
C==>1
D==>0
C==>1
D==>0
C==>1
D==>0
C==>1
D==>0
C==>1
D==>0

 

生产者、消费者问题（Lock版本）：

关于等待和通知的分析：

关于Condition：

代码演示：

package com.zibo;

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

/**
 * 线程之间的通信问题：生产者和消费者问题，等待唤醒，通知唤醒
 * 线程交替执行，A和B操作同一个变量 num=0
 * A num+1
 * B num-1
 */
public class B {
    public static void main(String[] args) {
        DataB data = new DataB();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }
        },"D").start();
    }
}

//等待、业务、通知
class DataB{
    private int num = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    //condition.await();//等待
    //condition.signalAll();//通知（唤醒）

    //+1
    public void increment(){
        lock.lock();
        try {
            while(num!=0){
                //等待操作
                condition.await();//等待
            }
            num++;
            System.out.println(Thread.currentThread().getName() + "==>" + num);
            //通知其他线程我加完了
            condition.signalAll();//通知（唤醒）
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //-1
    public void decrement() {
        lock.lock();
        try {
            while(num==0){
                //等待操作
                condition.await();//等待
            }
            num--;
            System.out.println(Thread.currentThread().getName() + "==>" + num);
            //通知其他线程我减完了
            condition.signalAll();//通知（唤醒）
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

运行结果：

A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
A==>1
D==>0
A==>1
D==>0
A==>1
D==>0
A==>1
D==>0
A==>1
D==>0
A==>1
D==>0
C==>1
D==>0
C==>1
D==>0
C==>1
D==>0
C==>1
D==>0
C==>1
B==>0
C==>1
B==>0
C==>1
B==>0
C==>1
B==>0
C==>1
B==>0
C==>1
B==>0

结果分析：

同样能够实现等待和通知，但目前看不出这种方式有什么优势，如果没有优势，为什么要用这种技术呢？（任何一种新的技术一定不仅仅是替代了旧的技术，一定有优势或补充）

假如我们想让A、B、C、D顺序执行呢？

 

Condition实现精准等待和通知：

代码演示：

package com.zibo;

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

/**
 * 线程之间的通信问题：生产者和消费者问题，等待唤醒，通知唤醒
 * 线程交替执行，A和B操作同一个变量 num=0
 * A num+1
 * B num-1
 */
public class C {
    public static void main(String[] args) {
        DataC data = new DataC();
        /*
         * A B C三个线程：A执行完，通知B执行，B执行完通知C执行，C执行完通知A执行，以此类推
         */
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printC();
            }
        },"C").start();
    }
}

//等待、业务、通知
class DataC{
    private int num = 1;//1A 2B 3C
    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();

    //A
    public void printA(){
        //加锁
        lock.lock();
        try {
            //业务——判断——执行——通知
            while(num!=1){
                //等待操作
                condition1.await();//等待
            }
            System.out.println(Thread.currentThread().getName() + "==>" + "AAA");
            //通知B执行
            num = 2;
            condition2.signal();//通知（唤醒）
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //解锁
            lock.unlock();
        }
    }

    //B
    public void printB(){
        lock.lock();
        try {
            //业务——判断——执行——通知
            while(num!=2){
                //等待操作
                condition2.await();//等待
            }
            System.out.println(Thread.currentThread().getName() + "==>" + "BBB");
            //通知C执行
            num = 3;
            condition3.signal();//通知（唤醒）
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //C
    public void printC(){
        lock.lock();
        try {
            //业务——判断——执行——通知
            while(num!=3){
                //等待操作
                condition3.await();//等待
            }
            System.out.println(Thread.currentThread().getName() + "==>" + "CCC");
            //通知C执行
            num = 1;
            condition1.signal();//通知（唤醒）
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

运行结果：

A==>AAA
B==>BBB
C==>CCC
A==>AAA
B==>BBB
C==>CCC
A==>AAA
B==>BBB
C==>CCC
A==>AAA
B==>BBB
C==>CCC
A==>AAA
B==>BBB
C==>CCC
A==>AAA
B==>BBB
C==>CCC
A==>AAA
B==>BBB
C==>CCC
A==>AAA
B==>BBB
C==>CCC
A==>AAA
B==>BBB
C==>CCC
A==>AAA
B==>BBB
C==>CCC

 

 

 

 

 

 

 

 

訾博ZiBo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JUC--001--Atomic-1
RuleBreaker
03-04 888
AtomicBoolean ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ public class AtomicBoolean implements java.io.Serializable { private static final Unsafe unsafe = Unsafe.getUnsafe(); private static final long valueOf.
JUC-001-volatile与内存可见性
qq_33605778的博客
11-22 592
JUC简介 在Java 5.0 提供了java.util.concurrent（简称JUC ）包，在此包中增加了在并发编程中很常用的实用工具类，用于定义类似于线程的自定义子系统，包括线程池、异步IO 和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的Collection 实现等。 内存可见性（Memory Visibility） 内存可见性（Memory Visibilit
学习笔记（1):Java系列技术之Java8新特性-001.Lambda表达式入门1
styxzhong的博客
06-29 158
系统地梳理Java8中特实用的新特性技术点！
多线程的理解
m0_54071716的博客
11-18 130
复习多线程第一天
并发问题之Java多线程
FunkyCode的博客
04-06 231
创建线程方式 第一种：继承 Thread public class MyThread extends Thread { @Override public void run() { System.out.println("通过集成 Thread 类实现线程"); } } // 如何使用 new MyThread().start() 第二种：实现 Runnable public class MyRunnable implements Runnable {
thread.zip--狂神多线程+juc
03-18
《狂神多线程+juc》是一份针对Java并发编程深度学习的资源包，主要涵盖了Java多线程基础以及Java并发工具集（JUC）的高级应用。在Java编程中，多线程是提高程序效率、实现并发执行的重要手段，而JUC（Java ...
Java 多线程与并发(12-26)-JUC锁- ReentrantReadWriteLock详解.pdf
07-26
ReentrantReadWriteLock包含两种类型的锁：读锁（ReadLock）和写锁（WriteLock），它们可以独立地被获取和释放，从而提高了多线程环境下的并发性能。 1. **为什么需要ReentrantReadWriteLock？** - ...
Java 多线程与并发(11-26)-JUC锁- ReentrantLock详解.pdf
07-26
Java中的ReentrantLock是Java并发包（java.util.concurrent.locks）中的一个高级锁，它是可重入的，意味着一个线程可以多次获取同一锁。在深入ReentrantLock之前，我们首先需要了解Java并发编程的基础，特别是Java...
JUC代码演示 Java多线程并发
最新发布
05-03
### Java多线程并发知识点详解 #### 一、用户线程与守护线程 在Java中，线程分为用户线程（User Thread）和守护线程（Daemon Thread）。这两种线程的区别主要在于程序退出的方式： - **用户线程**：默认创建的...
JUC多线程学习个人笔记
07-08
Java Util Concurrent（JUC）是Java并发编程的核心库，提供了丰富的工具和接口，使得开发者能够高效、安全地处理多线程环境中的并发问题。以下将详细介绍JUC中的关键概念和特性。 1. **线程池**：JUC通过Executor...
synchronized 关键字的使用详解+案例
renlong
07-16 454
synchronized 锁其实就是一个对象锁，我们用具体的例子来看看它到底是怎么运行的： 测试一： //同步锁失效，测试1 public class Syn1 { public synchronized void start(){ System.out.println("仰卧"); try { Thread.sleep(10...
synchronized详解
三分恶的博客
02-10 6361
synchronized是Java多线程中元老级的锁，也是面试的高频考点，让我们来详细了解synchronized吧。
并发编程（六）java Thread.start()源码解读
liushuailei的博客
12-06 323
线程对象在初始化完成之后，调用start()方法就可以启动这个线程。线程start()方法的含义是：当前线程（即parent线程）同步告知Java虚拟机，只要线程规划器空闲应立即启动调用start()
Java并发之synchronized解析
我的书包哪里去了
08-06 255
    线程安全是并发编程中的重要关注点，应该注意到的是，造成线程安全问题的主要诱因有两点，一是存在共享数据(也称临界资源)，二是存在多条线程共同操作共享数据。因此为了解决这个问题，我们需要用到synchronized。     Java语言的关键字synchronized，可用来给对象和方法或者代码块加锁，我们一般称之为互斥锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行...
synchronized同步方法简单介绍（一）
飞少fly的博客
05-16 2423
非线程安全和线程安全非线程安全：其实会在多个线程对同一个对象中的实例变量进行并发访问时产生，结果就是脏读。线程安全：获得的实例变量的值经过同步处理，不会出现脏读的现象。一个方法中的变量不存在非线程安全问题，永远都是线程安全的。这是因为方法内部的变量是私有特性造成的。代码如下解读public class HasSelfPrivateNum { public void addI(String us...
synchronized的四种用法
行走江湖的少侠哥
06-06 6万+
一  修饰一个方法 Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。 例如： 方法一 public synchronized void method() { // todo }方法二 public v
Java中Synchronized的用法
热门推荐
阳光日志
06-24 50万+
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 3.修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 4..
Java：多线程
qq_24325581的博客
08-02 121
一、什么是多线程 1、进程与线程 进程：当一个程序运行起来后就是一个单独的进程 线程：一个进程包含很多个线程，它是CPU调度的最小单元，由CPU一条一条的执行指令 2、并行与并发 并行：多核CPU运行多线程，每个核在同一时刻都有线程在运行 并发：单核CPU运行多线程，必须通过时间片切换才能实现，在同一时刻其实只能运行一个线程，但是在宏观上看该核也实现了多线程的运行 上下文切换：对于单核CPU来说，在同一个时刻只能运行一个线程，当在运行一个线程的过程中转去运行另一个线程，这个就叫做线程上下文转换。当然为了便于
Java并发编程(3)——synchronized
u010478214的博客
08-14 244
在Java中可以使用synchronized关键字来修饰方法、静态方法和代码块，synchronized能够隐式的获取和释放锁，从而保证在同一时刻，只有一个线程在方法或代码块中。public class SynchronizedDemo { public static int num = 0; public static void main(String[] args) {
Java JUC并发编程实例：守护线程与Synchronized锁
这个资源通过具体的代码实例，展示了Java多线程编程中的基础概念，包括如何使用用户线程和守护线程，以及如何利用JUC库中的同步机制（如`synchronized`和`Lock`）来处理并发场景中的数据一致性问题。这些知识对于有...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值