day07多线程

最新推荐文章于 2024-08-18 23:25:39 发布
最新推荐文章于 2024-08-18 23:25:39 发布
阅读量181 收藏
点赞数
分类专栏： java学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Huge_994/article/details/126309026
版权
本文介绍了Java中多线程的概念、优缺点，详细讲解了进程和线程的区别，以及Java实现线程的两种方式。内容包括线程状态、调度、合并、礼让、中断、同步、线程安全的单例模式和死锁等，还探讨了Lock接口和ReentrantLock的使用。
摘要由CSDN通过智能技术生成

Java写程序三部分组成:
1、JDK系统类库
JRE: Java Runtime Environment (Java运行环境)，仅供运行程序的。
JDK: Java Development Kit (Java开发工具包)，如果需要进行程序开发，必须安装JDK。
string、Scanner、包装类。。。
java.lang.Thread
javax.servlet.Servlet
2、第三方类库
非Java官方的组织提供的一些成熟好用的工具，C3PO数据库连接池、Spring框架、DBUtils、Dom…
github
3、开发者自定义的代码
根据具体的业务需求编写的业务代码。

1、多线程

多线程是提升程序性能非常重要的一种方式，必须掌握的技术。

使用多线程可以让程序充分利用CPU 资源。
优点
系统资源得到更合理的利用。

程序设计更加简洁。

程序响应更快，运行效率更高。

缺点
需要更多的内存空间来支持多线程。

多线程并发访问的情况可能会影响数据的准确性。

数据被多线程共享，可能会出现死锁的情况。

进程和线程

什么是进程:

进程就是计算机正在运行的一个独立的应用程序。

进程是一个动态的概念，当我们启动某个应用的时候，进程就产生了，当我们关闭该应用的时候，进程就结束了进程的生命周期就是我们

在使用该软件的整个过程。

什么是线程?

线程是组成进程的基本单位，可以完成特定的功能，一个进程是由一个或多个线程组成的。

应用程序是静态的，进程和线程是动态的，有创建有销毁，存在是暂时的，不是永久的。

进程和线程的区别

进程在运行时拥有独立的内存空间，即每个进程所占用的内存空间都是独立的，互不干扰。
线程是共享内存空间的，但是每个线程的执行都是相互独立的，单独的线程是无法执行的，由进程来控制多个线程的执行。
多线程
多线程是指在一个进程中，多个线程同时执行，这里说的同时执行并不是真正意义的同时执行。

系统会为每个线程分配CPU 资源，在某个具体的时间段内CPU 资源会被一个线程占用，

在不同的时间段内由不同的线程来占用CPU资源，所以多个线程还是在交替执行，只不过因为CPU运行速度太快，我们感觉是在同时执行。

整个程序如果是一条回路，说明程序只有一个线程。

程序有两条回路以上同时向下执行，就是多线程。

Java中线程的使用

Java中使用线程有两种方式:

  • 继承 Thread类

    1、创建自定义类并继承 Thread类。
    2、重写Thread类中的run方法，并编写该线程的业务逻辑代码。

    package com.southwind.java;

public class MyThread extends Thread{
    @Override
    public void run() {
         //定义业务逻辑
        for (int i = 0;i < 1000;i ++){
            System.out.println("--------MyTest");
        }
    }
}

    3、使用：

    package com.southwind.java;

public class Test {
    public static void main(String[] args) {
        //开启两个子线程
        MyThread myThread1 = new MyThread();
        MyThread2 myThread2 = new MyThread2();
        myThread1.start();
        myThread2.start();
    }
}

    注意:不能通过run方法来调用线程的任务，因为run方法调用相当于普通对象的执行，并不会去抢占CPU资源。
    只有通过start方法才能开启线程，进而去抢占CPU资源，当某个线程抢占到CPU资源后，会自动调用run方法。

  • 实现 Runnable接口

1、创建自定义类并实现Runnable接口。

2、实现run方法，编写该线程的业务逻辑代码。

package com.southwind.java;

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("====MyRunnable====");
        }
    }
}

package com.southwind.java;

public class MyRunnable2 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("!!!!!MyRunnable2!!!!");
        }
    }
}

3、实现

package com.southwind.java;

public class Test {
    public static void main(String[] args) {
        //开启两个子线程
//        MyThread myThread1 = new MyThread();
//        MyThread2 myThread2 = new MyThread2();
//        myThread1.start();
//        myThread2.start();
        //实例化Runnable
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
        MyRunnable2 runnable2 = new MyRunnable2();
        Thread thread2 = new Thread(runnable2);
        thread2.start();
    }
}

线程和任务:

线程是去抢占CPU资源的，任务是具体执行业务逻辑的，线程内部会包含一个任务，线程启动(start)，当抢占到资源之后，任务就开始执行(run)。

两种方式的区别:

1、MyThread，继承Thread类的方式，直接在类中重写run方法，使用的时候，直接实例化MyThread，start即可，因为 Thread内部存在Runnable。
1
2、MyRunnbale，实现Runnable接口的方法，在实现类中重写run方法，使用的时候，需要先创建 Thread对象，并将MyRunnable注入到Thread中,Thread.start。(推荐使用)

线程的状态

线程共有5种状态，在特定的情况下，线程可以在不同的状态之间切换，5种状态如下所示。

  • 创建状态:实例化一个新的线程对象,还未启动。
  • 就绪状态:创建好的线程对象调用start方法完成启动，进入线程池等待抢占CPU 资源。
  • 运行状态:线程对象获取了CPU 资源，在一定的时间内执行任务。
  • 阻塞状态:正在运行的线程暂停执行任务，释放所占用的CPU资源，并在解除阻塞状态之后也不能直接回到运行状态，而是重新回到就绪状态，等待获取 CPU资源。
  • 终止状态:线程运行完毕或因为异常导致该线程终止运行。

在这里插入图片描述

线程调度

  • 线程休眠

让当前线程暂停执行。从运行状态进入阻塞状态，将CPU资源让给其他线程池的调度方式，通过sleep（）来实现。

sleep（long millis），调用时需要传入休眠时间，单位为毫秒

内部调用sleep方法：

package com.southwind.diaodu;

public class MyThread extends Thread{
    @Override
    public void run() {
        for(int i = 0;i<10; i++) {
            if (i ==5){
                try {
                    sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(i+"-------MyThread");
        }
    }
}

package com.southwind.diaodu;
public class Test {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

外部调用sleep方法：

package com.southwind.diaodu;

public class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0;i<10;i++){
            System.out.println("MyThread2====="+i);
    }
        }
    }

package com.southwind.diaodu;
public class Test {
    public static void main(String[] args) {
//        MyThread thread = new MyThread();
//        thread.start();
        MyThread2 thread2 = new MyThread2();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.start();
    }
}

需要注意的是休眠一定要放在启动之前。

如何让主线程休眠？直接通过静态方式调用sleep方法。

package com.southwind.diaodu;

public class Test2 {
    public static void main(String[] args) {
        for (int i = 0;i<10;i++){
            if (i == 5){
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(i+"+++++Test2+++++");
        }
    }
}

public static native void sleep(long millis) throws InterruptedException;

sleep是静态方法，可以通过类调用，也可以通过对象调用，方法定义抛出InterruptedException，InterruptedException继承Exception，外部调用是必需手动处理异常。

线程合并

合并是将指定的某个线程加入到当前线程中，合并为一个线程，由两个线程交替执行变成一个线程中的两个子线程顺序执行。

通过调用join方法来实现合并，具体如何合并？

线程甲和线程乙，线程甲执行到某个时间点的时候调用线程乙的join方法，则表示从当前时间点开始CPU资源被线程乙独占，线程甲进入

阻塞状态，直到线程乙执行完毕，线程甲进入就绪状态，等待获取CPU资源进入运行状态。

join方法重载，join()表示乙线程执行完毕之后才能执行其他线程，join(long millis)表示乙线程执行millis 毫秒之后，无论是否执行完毕,其他线程都可以和它争夺CPU资源。

join(long millis():

package com.southwind.diaodu;

public class JoinRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0;i<100;i++){
            System.out.println(i+"-------JoinRunnable");
        }
    }
}

package com.southwind.diaodu;

public class JoinTest {
    public static void main(String[] args) {
        /**
         *两个线程:主线程、join线程
         * 主线程逻辑：当i==10时，join进程合并到主线程中
         */
        JoinRunnable joinRunnable= new JoinRunnable();
        Thread thread = new Thread(joinRunnable);
        thread.start();
        for (int i = 0;i<200;i++){
            if (i == 10){
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(i+"main+++++++++");
        }
    }
}

join(long millis（3000）：

package com.southwind.diaodu;

public class JoinRunnable2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0;i<20;i++){
            try {
                Thread.sleep(1000);//JoinRunnable延迟1秒输出一次
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i+"-------JoinRunnable");
        }
    }
}

package com.southwind.diaodu;

public class JoinTest2 {
    public static void main(String[] args) {
        JoinRunnable2 joinRunnable = new JoinRunnable2();
        Thread thread = new Thread(joinRunnable);
        thread.start();
        for (int i=0;i<100;i++){
            if (i == 10){
                try {
                    thread.join(3000);//join运行3秒后，其他线程可以开始抢占cpu资源
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(i+"++++++++main");
        }
    }
}

线程礼让

线程礼让是指在某个特定的时间点，让线程暂停抢占CPU资源的行为，运行状态/就绪状态—》阻塞状态，将CPU资源让给其他线程来使

用。

假如线程甲和线程乙在交替执行，某个时间点线程甲做出了礼让，所以在这个时间节点线程乙拥有了CPU资源,执行业务逻辑，但不代表线

程甲一直暂停执行。

线程甲只是在特定的时间节点礼让，过了时间节点，线程甲再次进入就绪状态，和线程乙争夺CPU资源。

通过yield方法实现。

package com.southwind.yield;

public class YieldThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0;i<10;i++){
            if (i == 5){
                yield();
            }
            System.out.println(Thread.currentThread().getName()+"---"+i);
        }
    }
}

package com.southwind.yield;

public class YieldThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"====="+i);
        }
    }
}

package com.southwind.yield;

public class Test {
    public static void main(String[] args) {
        YieldThread1 thread = new YieldThread1();
        thread.setName("线程1");
        YieldThread2 thread2 = new YieldThread2();
        thread2.setName("线程2");
        thread.start();
        thread2.start();
    }
}

线程中断

有很多种情况会造成线程停止运行:

线程执行完毕自动停止

线程执行过程中遇到错误抛出异常并停止线程执行过程中根据需求手动停止

Java中实现线程中断有如下几个常用方法:

  • public void stop()

  • public void interrupt()

  • public boolean isInterrupted()

stop方法在新版本的JDK已经不推荐使用，重点关注后两个方法。

interrupt是一个实例方法，当一个线程对象调用该方法时，表示中断当前线程对象。

每个线程对象都是通过一个标志位来判断当前是否为中断状态。

isInterrupted就是用来获取当前线程对象的标志位:true 表示清除了标志位，当前线程已经中断;false 表示没有清除标志位，当前对象没有中断。

当一个线程对象处于不同的状态时，中断机制也是不同的。

创建状态︰实例化线程对象，不启动。

package com.southwind.interrupted;

public class Test {
    public static void main(String[] args) {
        Thread thread = new Thread();
        System.out.println(thread.getState());
        thread.interrupt();
        System.out.println(thread.isInterrupted());
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PqCfbmEh-1660298044428)(C:\Users\xwh666\AppData\Roaming\Typora\typora-user-images\image-20220810104953386.png)]

NEW表示当前线程对象为创建状态，false表示当前线程并未中断，因为当前线程没有启动，不存在中断，不需要清除标志位。

package com.southwind.interrupted;

public class Test2 {
    public static void main(String[] args) {
//        Thread thread = new Thread(new Runnable() {
//            @Override
//            public void run() {
//                for (int i = 0;i<10;i++){
//                    System.out.println(i+"------main");
//
//                }
//            }
//        });
//        MyRunnable runnable = new MyRunnable();
//        Thread thread = new Thread(runnable);
//        thread.start();
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0;i<10;i++){
                    System.out.println(i+"-----main");
                }
            }
        });
        thread.start();
        System.out.println(thread.getState());
        System.out.println(thread.isInterrupted());
        System.out.println(thread.getState());
    }
}

线程同步

Java中允许多线程并行访问，同一时间段内多个线程同时完成各自的操作。

多个线程同时操作同一个共享数据时，可能会导致数据不准确的问题。

使用线程同步可以解决上述问题。

可以通过synchronized关键字修饰方法实现线程同步，每个Java对象都有一个内置锁，内置锁会保护使用synchronized关键字修饰的方法，要调用该方法就必须先获得锁，否则就处于阻塞状态。

非线程同步：

package com.southwind.test;

public class Account implements Runnable{
    private static int num;

    @Override
    public void run() {
        num++;
        try {
            Thread.currentThread().sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        System.out.println(Thread.currentThread().getName()+"是当前的第"+num+"位访问");
    }
}

package com.southwind.test;

public class Test {
    public static void main(String[] args) {
        Account account = new Account();
        Thread t1 = new Thread(account,"张三");
        Thread t2 = new Thread(account,"李四");
        t1.start();
        t2.start();
    }
}

线程同步：

package com.southwind.test;

public class Account implements Runnable{
    private static int num;

    @Override
    public synchronized void run() {//加synchronized关键字，线程一进入就上锁
        num++;
        try {
            Thread.currentThread().sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        System.out.println(Thread.currentThread().getName()+"是当前的第"+num+"位访问");
    }
}

package com.southwind.test;

public class Test {
    public static void main(String[] args) {
        Account account = new Account();
        Thread t1 = new Thread(account,"张三");
        Thread t2 = new Thread(account,"李四");
        t1.start();
        t2.start();
        for (int i = 0;i<10;i++){

            Thread thread = new Thread(account,"线程"+i);
            thread.start();
        }
    }
}

synchronized关键字可以修饰实例方法，也可以修饰静态方法，两者在使用的时候是有区别的。

package com.southwind.test;

public class SynchronizedTest {
    public static void main(String[] args) {
        for (int i = 0;i<5;i++){
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                SynchronizedTest.test();
                }
            });
            thread.start();
        }
    }
    public synchronized static void test(){
        System.out.println("start......");
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("end......");
    }

}

synchronized修饰（实例）非静态方法

package com.southwind.test;

public class SynchronizedTest2 {
    public static void main(String[] args) {
        for (int i = 0;i<5;i++){
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    SynchronizedTest2 synchronizedTest2 = new SynchronizedTest2();
                    synchronizedTest2.test();
                }
            });
            thread.start();
        }
    }
    public synchronized  void test(){
        System.out.println("start......");
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("end......");
    }

}

给实例方法（非静态方法）添加synchronized关键字并不能实现线程同步。

线程同步的本质是锁定多个线程所共享的资源，synchronized还可以修饰代码块，会为代码块加上内置锁，从而实现同步。

package com.southwind.test;

public class SynchronizedTest3 {
    public static void main(String[] args) {
        for (int i = 0;i<5;i++){
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {

                    SynchronizedTest3.test();
                }
            });
            thread.start();
        }
    }
    public static void test(){
        synchronized (SynchronizedTest3.class) {//synchronized修饰代码块
            System.out.println("start......");
            try {
                Thread.currentThread().sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end......");
        }
    }

}

如何判断线程同步还是不同步？

找到关键点：锁定的资源在内存中是一份还是多份？一份大家需要排队，线程同步，多份（一人一份）。线程不同步。

无论是锁定方法还是锁定对象、锁定类。只需要分析这个方法、对象、类在内存中有几份即可。

对象一般是多份

类一定是一份

方法就看是静态还是非静态方法，静态一定是一份，非静态方法一般是多份

线程安全的单例模式

单例模式是一种常见的软件设计模式，核心思想是一个类只有一个实例对象。

在这里插入图片描述

栈内存只能存基本数据类型

单线程模式下的：

package com.southwind.singleton;

public class SigletonDemo {
    private static SigletonDemo sigletonDemo;
    private SigletonDemo(){

        System.out.println("创建了 SingletonDemo...");

    }
    public static SigletonDemo getInstance(){
        if (sigletonDemo == null){
            sigletonDemo = new SigletonDemo();
        }

        return sigletonDemo;
    }

}

package com.southwind.singleton;

public class Test {
    public static void main(String[] args) {
//        SigletonDemo sigletonDemo = SigletonDemo.getInstance();
//        SigletonDemo sigletonDemo2 = SigletonDemo.getInstance();
//        SigletonDemo sigletonDemo3 = SigletonDemo.getInstance();
        for (int i = 0;i<10;i++){
            SigletonDemo sigletonDemo = SigletonDemo.getInstance();
        }
    }
}

多线程模式下：

package com.southwind.singleton;

public class SigletonDemo {
    private static SigletonDemo sigletonDemo;
    private SigletonDemo(){

        System.out.println("创建了 SingletonDemo...");

    }
    public synchronized static SigletonDemo getInstance(){//锁的范围太大了，需要改进
        if (sigletonDemo == null){
            sigletonDemo = new SigletonDemo();
        }

        return sigletonDemo;
    }

}

package com.southwind.singleton;

public class Test2 {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                SigletonDemo sigletonDemo = SigletonDemo.getInstance();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                SigletonDemo sigletonDemo = SigletonDemo.getInstance();
            }
        }).start();
    }
}

双重检测，synchronized修饰代码块

1、线程同步是为了实现线程安全，如果只创建一个对象，那么线程就是安全的。

2、如果synchronized锁定的是多个线程共享的数据（同一个对象），那么线程就是安全的。

（帮助理解）

package com.southwind.singleton;

public class SigletonDemo {
    private static SigletonDemo sigletonDemo;
    private SigletonDemo(){

        System.out.println("创建了 SingletonDemo...");

    }
    public static SigletonDemo getInstance(Integer i){
        if (sigletonDemo == null){
            synchronized (i){//锁的是同一个对象就是单例（值都是1,Integer看的是值一样就是同一个）
                if (sigletonDemo==null){
                    sigletonDemo = new SigletonDemo();
                }

            }

        }

        return sigletonDemo;
    }

}

package com.southwind.singleton;

public class Test2 {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                Integer a = Integer.parseInt("1");
                SigletonDemo sigletonDemo = SigletonDemo.getInstance(a);
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                Integer b = Integer.parseInt("1");//虽然是b但是值是1，所以就是同一个对象
                SigletonDemo sigletonDemo = SigletonDemo.getInstance(b);
            }
        }).start();
    }
}

3、volatile的作用是可以使内存中的数据对线程可见。

package com.southwind.singleton;

public class SigletonDemo {
    private volatile static SigletonDemo sigletonDemo;
    private SigletonDemo(){

        System.out.println("创建了 SingletonDemo...");

    }
    public static SigletonDemo getInstance(){
        if (sigletonDemo == null){
            synchronized (SigletonDemo.class){//最终版
                if (sigletonDemo==null){
                    sigletonDemo = new SigletonDemo();
                }

            }

        }

        return sigletonDemo;
    }

}

死锁

前提：一个线程完成业务需要同时访问两个资源。

死锁：多个线程同时在完成业务，出现争抢资源的情况。

炒一锅菜（一个线程）需要两个锅（两个资源），A拿了1锅，B拿了2锅，两边都炒不成，谁都不让

资源类：

package com.southwind.deadlock;

public class DeadLockRunnable implements Runnable {
    //编号
    public int num;
    //资源
    private static Chopsticks chopsticks1 = new Chopsticks();
    private static Chopsticks chopsticks2 = new Chopsticks();

    /**
     * num = 1,拿到chopsticks1，等待chopsticks2
     * num = 2,拿到chopsticks2，等待chopsticks1
     */
    @Override
    public void run() {
        if (num == 1) {
            System.out.println(Thread.currentThread().getName() + "拿到chopsticks1，等待chopsticks2");
            synchronized (chopsticks1) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            synchronized (chopsticks2) {
                System.out.println(Thread.currentThread().getName() + "用餐完毕");
            }
        }
    }
        if(num ==2) {
            System.out.println(Thread.currentThread().getName() + "拿到chopsticks2，等待chopsticks1");
            synchronized (chopsticks2) {

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (chopsticks1) {
                    System.out.println(Thread.currentThread().getName() + "用餐完毕");
                }

            }
        }}}

package com.southwind.deadlock;

public class DeadLockTest {
    public static void main(String[] args) {
        DeadLockRunnable deadLockRunnable1 = new DeadLockRunnable();
        deadLockRunnable1.num = 1;
        DeadLockRunnable deadLockRunnable2 = new DeadLockRunnable();
        deadLockRunnable2.num = 2;
        new Thread(deadLockRunnable1,"张三").start();
        new Thread(deadLockRunnable2,"李四").start();

    }
}

如何破解死锁？

不要让多线程并发

package com.southwind.deadlock;

public class DeadLockTest {
    public static void main(String[] args) {
        DeadLockRunnable deadLockRunnable1 = new DeadLockRunnable();
        deadLockRunnable1.num = 1;
        DeadLockRunnable deadLockRunnable2 = new DeadLockRunnable();
        deadLockRunnable2.num = 2;
        new Thread(deadLockRunnable1,"张三").start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(deadLockRunnable2,"李四").start();

    }
}

使用lambda表达式简化代码开发

package com.southwind.demo;

public class Test2 {
    public static void main(String[] args) {
        new Thread(()->{
            for (int i = 0;i<100;i++){
                System.out.println("+++++++++Runnable");
                System.out.println("++++-----Runnable");
                System.out.println("+++++====Runnable");
            }

        }).start();
    }
}

package com.southwind.demo;

public class Test2 {
    public static void main(String[] args) {
        new Thread(()->{for (int i = 0;i<100;i++) System.out.println("+++++++++Runnable");}).start();
        new Thread(()->{for (int i = 0;i<100;i++) System.out.println("++++-----Runnable");}).start();
        new Thread(()->{for (int i = 0;i<100;i++) System.out.println("++++=====Runnable");}).start();
    }
}

Lock

JUC：java.util.concurrent

Lock是一个接口，用来实现线程同步的，功能与synchronized一样。

Lock使用频率最高的实现类是ReentrantLock（重入锁），可以重复上锁

package com.southwind.lock;

import com.southwind.test.Account;

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

public class Test {
    public static void main(String[] args) {
        Account account = new Account();
        new Thread(account,"A").start();
        new Thread(account,"B").start();
    }
}
class A implements Runnable{
    private static int num;
    private Lock lock = new ReentrantLock();
    @Override
    public void run() {
        lock.lock();
        num++;
        System.out.println(Thread.currentThread().getName()+"是当前的第"+num+"位访客");
        lock.unlock();
    }
}

实现资源和Runnable接口的解耦合。

package com.southwind.lock;


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

public class Test {
    public static void main(String[] args) {
        Account account = new Account();
        new Thread(()->{
            account.count();
        },"A").start();
        new Thread(()->{
            account.count();
        },"B").start();

//        new Thread(account,"A").start();
//        new Thread(account,"B").start();
    }
}
    class Account{
    private int num;
    private Lock lock = new ReentrantLock();

    public void count(){
        lock.lock();
        num++;
        System.out.println(Thread.currentThread().getName()+"是第"+num+"位访客");
        lock.unlock();
    }
}

重入锁

JUC：java.util.concurrent

java并发编程工具包，java官方提供的一套专门用来处理并发编程的工具集合（接口+类）

并发：单核CPU，多个线程“同时“运行，实际是交替执行，只不过速度太快，看起来是同时执行。

两个厨师一口锅

并行：多核CPU，真正的多个线程同时运行。

两个厨师两口锅

重入锁是JUC使用频率非常高的一个类ReentrantLock

ReentrantLock就是对Synchronized的升级，目的也是为了实现线程同步。

  • ReentrantLock是一个类，synchronized是一个关键字
  • ReentrantLock是JDK实现，synchronized是JVM实现
  • ReentrantLock手动释放锁，synchronized自动释放锁

公平锁：线程同步时，多个线程排队，依次执行

非公平锁：线程同步时，可以插队

  • 继承Thread
  • 实现Rnnable

实现Runnable的耦合度更低

package com.southwind.reentrantLock;

import com.southwind.reentrantLock.Account;

import java.util.concurrent.TimeUnit;


public class Test {
    public static void main(String[] args) {
        Account account = new Account();
//         new Thread(new Runnable() {
//             @Override
//             public void run() {
//                 account.count();
//             }
//         },"A").start();
        new Thread(()->{      //lambda表达式是上面的简写
            account.count();
        },"A").start();
        new Thread(()->{
            account.count();
        },"A").start();
    }
}
class Account{
    private static int num;
    public void count(){

        num++;
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"是当前第"+num+"位访客");
    }
}

在这里插入图片描述

Tips

package com.southwind.reentrantLock;

import com.southwind.reentrantLock.Account;

import java.util.concurrent.TimeUnit;


public class Test {
    public static void main(String[] args) {
        Account account = new Account();
//         new Thread(new Runnable() {
//             @Override
//             public void run() {
//                 account.count();
//             }
//         },"A").start();
        new Thread(()->{      //lambda表达式是上面的简写
            account.count();
        },"A").start();
        new Thread(()->{
            account.count();
        },"A").start();
    }
}
class Account{
    private static Integer num = 0;//要设定初始值否则会空指针异常
    private static Integer id = 0;
//    public synchronized void count(){//可以加synchronized关键字
        public void count(){
        synchronized (id){//可以锁Account.class类,也可以锁id(因为id不变,而num++了所以会变
            num++;
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"是当前第"+num+"位访客");

        }
       }
}

锁id可以同步，锁num不能同步原因是什么？

synchronized必须锁定唯一的元素才可以实现同步

id不变所以是唯一的元素,而num++了，num锁指向的引用一直在变，所以不是唯一的元素，肯定无法实现同步。

ReentrantLock

package com.southwind.reentrantLock;

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

public class Test3 {
    public static void main(String[] args) {
        Account3 account3 = new Account3();
        new Thread(()->{
            account3.count();
        },"A").start();
        new Thread(()->{
            account3.count();
        },"B").start();



    }
}
class Account3{
    private static int num;
    private ReentrantLock reentrantLock= new ReentrantLock();
    public void count(){
        //上锁
        reentrantLock.lock();
        num++;
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"当前的第"+num+"位访客");
        //解锁
        reentrantLock.unlock();
    }
}
  • Lock上锁和解锁都需要开发者手动完成
  • 可以重复上锁，上几把锁就要解几把锁
Huge_994
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程-day02.docx
12-12
在“多线程-day02”的学习资源中，我们深入探讨了Java内存模型以及多线程的特性与控制机制。 **Java内存模型** Java内存模型，也称为JVM内存模型，是Java程序员理解和掌握的基础知识，特别是在进行并发编程时。它...
多线程-day01.docx
12-12
在 Java 中，多线程是并发编程的重要概念，它允许程序同时执行多个任务，从而提高系统效率和资源利用率。在本教程中，我们将探讨多线程的基础知识，包括并发与并行的区别，进程与线程的概念，以及如何在 Java 中创建...
多线程_Day01
Anoraker的小屋
02-03 7028
多线程 程序 进程 线程 程序是为了完成特定的任务，用某种语言编写的一组指令的集合，通常指一段静态的代码 进程是程序的一次成型过程或者是正在运行的程序，是一个动态的过程，有它自身的产生，存在和消亡的过程，称为生命周期 线程是进程的细化，是一个进程内部的一个执行路径， 多线程的优点 提高应用程序的响应 提高计算机系统CPU的利用率 改善程序结构，将即长有复杂的进程分为多个线程，独立运行，有利于理解和修改 线程的创建和使用 第一种创建方式 创建一个继承Thread类的子类 重写父类Thread类ru
多线程day1-1
weixin_43695211的博客
05-28 1346
多线程 创建多线程方式： Thread public class ThreadTest01 extends Thread{ private String url; private String name; public ThreadTest01(String url,String name){ this.url=url; this.name=name; } //多线程执行体 @Override ..
day12 多线程
zhangnobill的博客
08-02 1203
线程(Thread)是一个程序内部的一条执行流程。程序中如果只有一条执行流程，那这个程序就是单线程的程序。多线程是指从软硬件上实现的多条执行流程的技术（多条线程由CPU负责调度执行）。多个线程，同时操作同一个共享资源的时候，可能会出现业务安全问题。线程同步是线程安全问题的解决方案。
Day29 多线程
yjp1240201821的博客
04-02 856
本节主要讲解Java的多线程，从Java的多线程的含义、单进程操作系统和多进程操作系统的区别、什么是线程，理解线程和进程的关系、线程的优先级别等等来帮助深刻理解Java的多线程。
多线程_Day02
Anoraker的小屋
02-04 7002
多线程 线程的生命周期 新建 ： (初始状态)调用Thread子类对象的start()方法 就绪 : 获取CPU执行权进入就绪状态， 如果失去执行权或调用yield()方法就会到新建状态 运行 : 在获取就绪状态时开始运行run()方法, 或线程调用stop()以及出现异常没处理线程结束 死亡 : (最终状态)程序结束运行 阻塞 : (不是最终状态)线程在执行时调用sleep(long millis)和join()方法以及等待同步锁,wait(),suspend() 线程的同步 多个线程执行的
多线程-day03.docx
12-12
【多线程-day03.docx】文档主要讨论了如何实现一个高效的秒杀系统，其中涉及到了多线程技术在高并发场景下的应用。以下是基于文档内容解析出的相关知识点： 1. **秒杀业务流程**： - 商家提交秒杀商品申请，包括...
day15多线程.md
07-24
day15多线程.md
day11-多线程 java
06-10
day11-多线程 java
JAVA进阶补充
2301_80150315的博客
08-15 963
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
Java基础之原反补码
u012135697的博客
08-14 485
整数类型数据在计算机底层进行存储或运算，以补码方式进行！ 正整数的原反补码，一模一样！
【Spring框架】
m0_71941456的博客
08-18 645
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1108
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 861
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
网上商品订单转手系统bootpf
weixin_43213064的博客
08-18 394
【代码】springboot网上商品订单转手系统bootpf
指针详解（四）
最新发布
Limerence_Aries的博客
08-18 626
目录1. 字符指针变量2. 数组指针变量3. 数组指针变初始化4. 二维数组传参的本质5. 函数指针变量1）函数指针变量的创建2）函数指针变量的使用3）代码解析6. typedef关键字7. 函数指针数组8. 转移表 代码const char* pstr = "hello bit."; 不是把字符串 hello bit 放到字符指针 pstr 里，而是把字符串hello bit.的首字符的地址放到了pstr中我们通过一道例题加深理解 所以数组指针变量：存放的应该是数组的地址，能够指向数组的指针变
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 428
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
旅游网站
weixin_43213064的博客
08-16 1049
【代码】springboot旅游网站
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值