JUC（1）

最新推荐文章于 2022-10-30 11:21:12 发布
最新推荐文章于 2022-10-30 11:21:12 发布
阅读量186 收藏
点赞数
分类专栏： java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56289903/article/details/124581534
版权

文章基于【狂神说Java】JUC并发编程最新版通俗易懂_哔哩哔哩_bilibili 视频总结而来

目录

1. 什么是 JUC

2. 线程和进程

3.Lock锁

4.生产者和消费者问题

5.Conditional

6. 锁问题

1. 什么是 JUC

juc就是 java并发包

java.util.concurrent JUC

java.util.concurrent.atomic 原子性

java.util.concurrent.locks lock锁

java.util.function 函数式方法

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

2. 线程和进程

进程：

  • 一个程序，本质是程序的集合，可执行。
  • 一个进程往往包含多个线程，至少一个。
  • JAVA默认有两个线程 main GC

线程： 开了一个进程，对JAVA而言：Thread，Runnable，Callable

“java真的可以开启线程吗”

我们new一个thread：

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

我们进入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();		//调用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 */
            }
        }
    }

可以看到 start 方法是一个安全的被synchronized修饰的方法。核心是调用start0方法。

private native void start0();

可以看大start0是一个被native修饰的方法，也就是本地方法。

本地方法实际调用了底层的C++方法，java无法直接操作硬件

并发和并行

并发编程： 并发、并行

并发（多个线程操作同一个资源）

        一核心CPU模拟出来的多条线程，快速交替

并行（多个人一起走）

        多核心CPU多个线程同时执行；线程池、

public class Test1 {
    public static void main(String[] args) {
        // 获取处理器核心数
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

并发编程的本质： 充分运用CPU的资源

线程有几个状态

    public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }

可以看到一共有六个状态：

1. 新生 NEW
1. 运行 RUNNABLE
1. 阻塞 BLOCKED
1. 等待，死等 WAITING
1. 超时等待 TIMED_WAITING
1. 中止 TERMINATED

wait 和 sleep的区别：

1. 类不同：

                wait 是 object类

                sleep 是 Thread类

2. 关于锁的释放

        wait会释放锁，sleep不会释放

3. 适用范围不同

        wait必须在同步代码块中

        sleep可以在任何地方

4. 需要捕获异常

        wait不需要捕获异常

        sleep可能会发生超时等待的情况，需要捕获异常

3.Lock锁

传统synchronize锁

package com.demo;

/**
 * @author Zeyu Wan
 * @version 1.0.0
 * @ClassName SaleTicket.java
 * @Description 买票的例子
 *              线程就是一个单独的资源类，没有任何附属
 *              1. 属性
 *              2. 方法
 * @createTime 2022年04月27日 10:11:00
 */
public class SaleTicket {
    public static void main(String[] args) {
        //并发：多线程操作同一个资源类
        Ticket ticket = new Ticket();


        //@FunctionInterface 函数式接口： 在jdk1.8后使用lambda表达式
        //lambda表达式： (参数)->{ 代码 }，名字

        new Thread(()->{
            for (int i = 0; i <60 ; i++) {
                ticket.sale();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i <60 ; i++) {
                ticket.sale();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i <60 ; i++) {
                ticket.sale();
            }
        },"C").start();
    }

    /**
     * 资源类OOP
     */
    static class Ticket{
        private int number = 50;
        public void sale(){
            if (number>0){
                System.out.println(Thread.currentThread().getName()+"卖出了"+number--+"张票。"+" 余票："+number);
            }
        }
    }
}

上面的代码会出现线程并发问题，也就是争抢线程的时候，顺序完全乱掉

 这时候，最简单的方式就是加synchronized同步锁，来达到顺序执行的目的

static class Ticket{
    private int number = 30;
    // synchronized 原理就是排队，
    public synchronized void sale(){
       if (number>0){
          System.out.println(Thread.currentThread().getName()+"卖出了"+number--+"张票。"+" 余票："+number);
       }
    }
}

 

Lock

 Lock lock = new ReentrantLock();

我们看到ReentrantLock的源码：

    /**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

        可以看到，无参构造的时候，进来的是一个非公平锁，如果传参，可以根据Boolean值来确定创建的锁是公平锁还是非公平锁

公平锁：

        十分公平，先来后到

非公平锁：

        不公平，可以插队

修改代码使用Lock加锁，一样可以实现加锁的功能 ：

    static class Ticket2{
        private int number = 30;
        Lock lock = new ReentrantLock();
        public void sale(){
            lock.lock(); //加锁
            try {
                //业务代码
                if (number>0){
                    System.out.println(Thread.currentThread().getName()+"卖出了"+number--+"张票。"+" 余票："+number);
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();  //解锁
            }
        }
    }

synchronize锁和lock的区别

  1. synchronize 是java内置的关键字，lock 是一个java类

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

  3. synchronize 可以自动释放锁，lock 需要手动释放，不释放会出现死锁

  4. synchronize 线程1（获得锁，阻塞）、线程2（等待），Lock 锁不一定会等待。可以通过

     lock.tryLock()

    方法尝试获取锁

  5. synchronize 可重入锁，非公平；lock， 可重入锁，可判断锁，非公平锁（可以自己设置种类）；

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

4.生产者和消费者问题

生产者和消费者的synchronize问题

package com.demo.pc;

/**
 * @author Zeyu Wan
 * @version 1.0.0
 * @ClassName A.java
 * @Description 线程通信问题：
 *              A,B操作同一个线程： 通知唤醒，等待唤醒
 * @createTime 2022年04月27日 13:24:00
 */
public class A {

    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{
            for (int i = 0; i <30 ; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i <30 ; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"B").start();
    }
}

class Data{
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
        if(number != 0){
            //等待操作
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知线程，操作完毕
        this.notifyAll();
    }

    public synchronized  void  decrement() throws InterruptedException {
        if (number==0){
            //等待操作
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知线程，操作完毕
        this.notifyAll();
    }
}

如果有4个线程呢，就会出现虚假唤醒问题

解决办法： 等待应该总是出现在循环中，if 改为 while判断

package com.demo.pc;

/**
 * @author Zeyu Wan
 * @version 1.0.0
 * @ClassName A.java
 * @Description 线程通信问题：
 *              A,B操作同一个线程： 通知唤醒，等待唤醒
 * @createTime 2022年04月27日 13:24:00
 */
public class A {

    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{
            for (int i = 0; i <30 ; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i <30 ; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i <30 ; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"C").start();

        new Thread(()->{
            for (int i = 0; i <30 ; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"D").start();
    }

}

class Data{
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
        while (number != 0){
            //等待操作
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知线程，操作完毕
        this.notifyAll();
    }

    public synchronized  void  decrement() throws InterruptedException {
        while (number==0){
            //等待操作
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知线程，操作完毕
        this.notifyAll();
    }
}

5.Conditional

package com.demo.pc;

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

/**
 * @author Zeyu Wan
 * @version 1.0.0
 * @ClassName A.java
 * @Description 线程通信问题：
 *              A,B操作同一个线程： 通知唤醒，等待唤醒
 * @createTime 2022年04月27日 13:24:00
 */
public class A {

    @SuppressWarnings("AlibabaAvoidManuallyCreateThread")
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{
            for (int i = 0; i <30 ; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i <30 ; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i <30 ; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"C").start();

        new Thread(()->{
            for (int i = 0; i <30 ; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"D").start();
    }

}

class Data{
    private int number = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    public void increment() throws InterruptedException {
        lock.lock();
        try {
            while (number != 0){
                //等待操作
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知线程，操作完毕
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public synchronized  void  decrement() throws InterruptedException {
        lock.lock();
        try {
            while (number==0){
                //等待操作
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知线程，操作完毕
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

可以得到和synchronize一样的结果 。

conditional 的优势，可以精准通知和唤醒线程

package com.demo.pc;

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

/**
 * @author Zeyu Wan
 * @version 1.0.0
 * @ClassName B.java
 * @Description A执行完调用B，B执行完调用C，C执行完调用A
 * @createTime 2022年04月27日 17:20:00
 */
public class B {
    public static void main(String[] args) {
        Data3 data = new Data3();

        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();
    }

   static class Data3{
        private final Lock lock = new ReentrantLock();
        private final Condition condition1 = lock.newCondition();
        private final Condition condition2 = lock.newCondition();
        private final 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()+"A");
                number++;
                condition2.signal();

            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
        public void printB(){
            lock.lock();
            try {
                while (number!=2){
                    condition2.await();
                }
                System.out.println(Thread.currentThread().getName()+"B");
                number++;
                condition3.signal();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
        public void printC(){
            lock.lock();
            try {
                while (number!=3){
                    condition3.await();
                }
                System.out.println(Thread.currentThread().getName()+"C");
                number=1;
                condition1.signal();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    }
}

通过监视器指定唤醒

6. 锁问题

Q1：以下代码是会先发短信还是先打电话

package com.demo.pc;

import java.util.concurrent.TimeUnit;

/**
 * @author Zeyu Wan
 * @version 1.0.0
 * @ClassName Lock8.java
 * @Description 8锁，就是锁的8个问题
 * @createTime 2022年04月28日 10:58:00
 */
public class Lock8 {

    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(()->{
            phone.sendMessage();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(()->{
            phone.phoneCall();
        },"B").start();
    }
}
class Phone{
    public synchronized void sendMessage(){
        System.out.println("Send message");
    }

    public synchronized void phoneCall(){
        System.out.println("call");
    }
}

Q2：如果我们让sendMessage延迟4秒，先发短信还是打电话

package com.demo.pc;

import java.util.concurrent.TimeUnit;

/**
 * @author Zeyu Wan
 * @version 1.0.0
 * @ClassName Lock02.java
 * @Description TODO
 * @createTime 2022年04月28日 14:28:00
 */
public class Lock02 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();

        new Thread(()->{
            phone.sendMessage();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(()->{
            phone.phoneCall();
        },"B").start();
    }
}
class Phone2 {
    public synchronized void sendMessage() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("Send message");
    }

    public synchronized void phoneCall() {
        System.out.println("call");
    }
}

        Q1和Q2都是锁的问题，我们使用synchronize关键字， 锁的对象是方法的调用者（对象锁：phone），也就是我们new的phone对象，不论是phoneCall还是sendMessage，都拿到的是同一把锁，所以谁先拿到，谁先执行。

Q3： 我们增加一个普通方法hello方法，然后让线程B去调用hello，是先发短信还是hello 

package com.demo.pc;

import java.util.concurrent.TimeUnit;

/**
 * @author Zeyu Wan
 * @version 1.0.0
 * @ClassName Lock8.java
 * @Description 8锁，就是锁的8个问题
 * @createTime 2022年04月28日 10:58:00
 */
public class Lock8 {

    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(()->{
            phone.sendMessage();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(()->{
            phone.hello();
        },"B").start();
    }
}
class Phone{
    public synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("Send message");
    }

    public synchronized void phoneCall(){
        System.out.println("call");
    }
	
    //这里没有锁
    public void hello(){
        System.out.println("hello");
    }
}

因为hello没有锁，不受锁的影响，所以先打印出hello，再打印的SendMessage

Q4：我们新建一个对象phone2，用第一个对象去调用发短信方法，第二个对象去调用打电话方法，哪一个先执行？

package com.demo.pc;

import java.util.concurrent.TimeUnit;

/**
 * @author Zeyu Wan
 * @version 1.0.0
 * @ClassName Lock03.java
 * @Description TODO
 * @createTime 2022年04月28日 14:44:00
 */
public class Lock03 {
    public static void main(String[] args) {
        Phone3 phone = new Phone3();
        Phone3 phone2 = new Phone3();
        
        new Thread(() -> {
            phone.sendMessage();
        }, "A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(() -> {
            phone2.phoneCall();
        }, "B").start();
    }
}
    class Phone3 {
        public synchronized void sendMessage() {
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("Send message");
        }

        public synchronized void phoneCall() {
            System.out.println("call");
        }
    }

        这时候两个对象，所以有两把锁，phong和phong2拿到的是不一样的锁，所以就按实现之星，先打电话，再发短信

Q5： 如果我们把打电话和发短信的方法换成静态方法，会先执行哪一个? 

package com.demo.pc;

import java.util.concurrent.TimeUnit;

/**
 * @author Zeyu Wan
 * @version 1.0.0
 * @ClassName Lock.java
 * @Description TODO
 * @createTime 2022年04月28日 14:52:00
 */
public class Lock04 {
    public static void main(String[] args) {
        Phone4 phone = new Phone4();

        new Thread(() -> {
            phone.sendMessage();
        }, "A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(() -> {
            phone.phoneCall();
        }, "B").start();
    }
}
class Phone4 {
    public static synchronized void sendMessage() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("Send message");
    }

    public static synchronized void phoneCall() {
        System.out.println("call");
    }
}

        我们使用static修饰，类一加载的时候就有了，所以synchronize锁的是这个class模板。在我们用static修饰方法的时候，我们的 Class Phone4就只有一个class对象，所以两个调用拿到的是同一把锁。

Q6： 两个对象，phone和phone2，phone调用发短信方法，phone2调用打电话方法，会先发短信还是先打电话？

package com.demo.pc;

import java.util.concurrent.TimeUnit;

/**
 * @author Zeyu Wan
 * @version 1.0.0
 * @ClassName Lock.java
 * @Description TODO
 * @createTime 2022年04月28日 14:52:00
 */
public class Lock04 {
    public static void main(String[] args) {
        Phone4 phone = new Phone4();
        Phone4 phone2 = new Phone4();
        new Thread(() -> {
            phone.sendMessage();
        }, "A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(() -> {
            phone2.phoneCall();
        }, "B").start();
    }
}
class Phone4 {
    public static synchronized void sendMessage() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("Send message");
    }

    public static synchronized void phoneCall() {
        System.out.println("call");
    }
}

        我们使用static修饰，synchronize是锁住了这个Class模板，所以及时是两个对象，但是拿到的还是同一把锁，所以是下发短信再打电话

Q7： 一个静态同步方法，一个普通同步方法hello，一个对象调用，先发短信还是先hello

package com.demo.pc;

import java.util.concurrent.TimeUnit;

/**
 * @author Zeyu Wan
 * @version 1.0.0
 * @ClassName Lock5.java
 * @Description TODO
 * @createTime 2022年04月28日 15:03:00
 */
public class Lock5 {
    public static void main(String[] args) {
        Phone5 phone = new Phone5();

        new Thread(() -> {
            phone.sendMessage();
        }, "A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(() -> {
            phone.hello();
        }, "B").start();
    }
}
class Phone5 {
    public static synchronized void sendMessage() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("Send message");
    }

    public static synchronized void phoneCall() {
        System.out.println("call");
    }

    public synchronized void hello(){
        System.out.println("hello");
    }
}

        会先执行hello，再执行发短信，因为static所得是class模板，普通同步方法所得是调用对象，不是一个锁所以先执行了hello

总结：

锁去锁住的东西一般分为两种，一种是new出来的对象，一种是static的，也就是类一开始就加载出来的class模板对象。锁是否执行，需要注意是不是同一个对象，同一把锁。

PigeonEssence
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JUC1 指令翻译 v1.0.rar
06-14
《JUC1指令翻译v1.0：深入理解微指令与指令系统》 在计算机科学领域，指令系统是计算机硬件和软件之间的桥梁，它定义了计算机可以执行的操作。JUC1模型机是一种教学用的简单计算机模型，其设计用于帮助学生理解和...
JUC个人笔记1
08-04
在Java并发编程中，"JUC个人笔记1"主要探讨了多线程并发控制的一些核心概念和技巧。首先，遵循高内聚低耦合的原则，将线程的操作与资源类进行解耦，使得代码结构更加清晰，易于维护。在多线程交互中，特别是涉及到`...
java Native Method初涉
ghsea
04-19 1400
    今天花了两个小时把一份关于什么是Native Method的英文文章好好了读了一遍，以下是我依据原文的理解。 一. 什么是Native Method    简单地讲，一个Native Method就是一个java调用非java代码的接口。一个Native Method是这样一个java的方法：该方法的实现由非java语言实现，比如C。这个特征并非java所特有，很多其它的编程语言都有这一...
Java线程
m0_63404275的博客
10-02 390
详细介绍Java中线程的创建、启用以及线程的几种状态
JAVA并发编程(一)之线程的概念
JALJA
11-14 203
线程：线程是操作系统能够进行运算调度的最小单位，是进程中独立运行的子任务即线程是进程中的实际运作单位；一个进程中可以并发多个线程，每条线程并行执行不同的任务。同一进程中的多条线程将共享该进程中的全部系统资源， 所以线程之间互相通信不必像进程通信那么麻烦(调用内核),直接利用共享资源就可以实现通信, 但每个线程有各自的调用栈（call stack），自己的寄存器环境（register context），自己的线程本地存储（thread-local storage）
快速掌握并发编程 --- 基础篇
m0_67698950的博客
07-29 149
而线程是共享进程中的数据的，使用相同的地址空间，因此CPU切换一个线程的花费远比进程要小很多，同时创建一个线程的开销也比进程要小很多，线程的上下文切换的性能消耗要小于进程。在当代面向线程设计的计算机结构中，进程是线程的容器。调用stop()方法会立刻停止run()方法中剩余的全部工作，包括在catch或finally语句中的，并抛出ThreadDeath异常(通常情况下此异常不需要显示的捕获)，因此可能会导致一些清理性的工作的得不到完成，如文件，数据库等的关闭。...
Native关键字
欢迎一起学习交流
03-24 313
引出场景，创建一个线程并使其就绪 public class Test { public static void main(String[] args) { Thread thread = new Thread(); thread.start(); } } 按住crlt进入Thread类查看start()方法 public synchronized void start() { /** * This method is
Java——JUC
12-29
1. **线程池（ExecutorService）** - 线程池是JUC中的核心组件，它允许开发者有效地管理和控制线程资源，避免频繁创建和销毁线程带来的性能开销。通过`ExecutorService`接口及其实现类如`ThreadPoolExecutor`，可以...
juc详解juc详解juc详解juc详解juc详解juc详解juc详解
最新发布
08-02
1. **线程池（ExecutorService）**： - `ExecutorService`是线程池的核心接口，它负责管理线程的创建和执行。通过`Executors`类提供的静态工厂方法，可以创建不同类型的线程池，如`FixedThreadPool`、`...
juc aqs java
12-14
juc 的aqs介绍。
线程的生命周期
master_hxh
02-21 223
线程的生命周期一共分为五个部分分别是：新建，就绪，运行，阻塞以及死亡。由于cpu需要在多条线程中切换因此线程状态也会在多次运行和阻塞之间切换. 当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，它要经过新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Dead）五种状态。尤其是当线程启动以后，它不能一直“霸占”着CPU独自运行，所以CPU需要在多条线程之间切换，于是线程状态也会多次在运行、阻塞之间切换。 生命周
线程调用start 和 run 什么区别？会有什么效果
samuBO的博客
10-12 1158
start() 它的作用是启动一个新线程。 通过start()方法来(private native void start0();)启动的新线程，处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行相应线程的run()方法，这里方法run()称为线程体，它包含了要执行的这个线程的内容，run方法运行结束，此线程随即终止。start()不能被重复调用。用start方法来启动线程，真正实现了多线程运行，即无需等待某个线程的run方法体代码执行完毕就直接继续执行下面的代码。这里无需等待run方法.
程序员必知必会：Java 高阶知识点
抱朴守拙
05-12 523
编程语言 Java 1、面向对象的四个基本特征：抽象，封装，继承，多态 抽象：包括数据抽象与行为抽象； 继承：类支持单继承，接口支持多继承 封装：包括重载（overload）和重写（override），前者属于编译型多态，后者属于运行时多态。 只能被 invokestatic 和 invokespecial 指令调用的方法，都可以在解析阶段中确定唯一的调用版本，符合这个条件的有静态方法、私有方法...
【狂神说笔记】JUC并发编程（多线程进阶）
qq_48575500的博客
04-28 1253
源码+官方文档（面试高频）进程：Java真的能开启线程吗？并发：（多线程操作同一资源）并行：（多个人同时走路）并发编程的本质：充分利用CPU的资源 2.6、wait和sleep的区别 来自不同的类：关于锁的释放使用的范围是不同的是否需要捕获异常参考链接参考链接作用：用法：怎么理解：实例： 3.2、Lock接口（Lock锁） 公平锁：十分公平，先来后到（排队）3h 3s非公平锁：不公平，可以插队（为了“公平”，引入非公平锁）–默认Lock锁“三部曲”： 3.4、synchronized 和 Lock 的区别
多线程（基础）
Maddoxzhi的博客
10-30 194
进程是进程实体的运行过程，是系统进行资源分配和调度的一个独立单位 进程实体（进程映像）：由程序段、相关的数据段和PCB（进程控制块）三部分构成 线程是一个基本的CPU执行单元，也是程序执行流的最小单位。线程是为了减少程序并发执行时的开销引入的。
狂神说JAVA-JUC并发编程（一）线程、生产者消费者、锁、synchronized、Lock
想握住此生辽阔
01-28 693
1
厚积薄发打卡Day26：狂神说Java之JUC并发编程＜代码+笔记＞（上）
COOLGWAYNE_TECH_BLOG
02-28 1366
前言： 学习视频来源：【狂神说Java】JUC并发编程最新版通俗易懂 一个十分优秀且励志的技术大牛+Java讲师，十分推荐他的频道：遇见狂神说 ???????????? 至于为啥这篇文章不是”全网最全“了，是因为狂神自己总结了一份学习笔记哈哈，本文是根据学习资料自己总结，方便以后查漏补缺???? 狂神置顶评论： (置顶) 白漂有罪，拒绝白嫖，从点赞转发关注做起！ 文章同步在公众号：狂神说 （公众号日更，记得关注） 视频文档地址：https://gitee.com/kuangstudy/openclass
java中native的用法
absolute_chen的博客
05-30 937
前言： 在查看 Thread.java 文件时，发现有一个 方法比较特殊 private native void start0(); 概念： native关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是在用其他语言（如C和C++）实现的文件中。Java语言本身不能对操作系统底层进行访问和操作，但是可以通过JNI接口调用其他语言来实现对底层的访问。 JNI是Java...
了解Java线程的start方法如何回调run方法
itmyhome的专栏
11-07 6890
Java 创建线程的方法实际上，创建线程最重要的是提供线程函数（回调函数），该函数作为新创建线程的入口函数，实现自己想要的功能。Java 提供了两种方法来创建一个线程：继承 Thread 类class MyThread extends Thread{ public void run() { System.out.println("My thread is start
Java并发编程详解：JUC与面试必备知识
1. JUC相关包介绍： - `java.util.concurrent`：这是JUC的核心包，包含各种并发工具类，如ExecutorService、Future、Callable、BlockingQueue等。 - `java.util.concurrent.atomic`：提供了原子操作类，如...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

PigeonEssence

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值