Java基础知识多线程，同步锁

最新推荐文章于 2022-06-08 19:07:58 发布
最新推荐文章于 2022-06-08 19:07:58 发布
阅读量164 收藏 2
点赞数
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49087146/article/details/123747568
版权

多线程

/*
    多线程: 多任务执行,多路径执行
    优点:
        提高性能
        提高效率

    进程与线程之间的区别:
        进程 : 系统中的程序,一个进程之间可以包含1~n个线程,系统中资源分配的最小单位,每个进程都有自己的代码与数据空间,进程之间的切换开销较大
        线程 : 程序中的顺序流,线程是cpu调度与执行的最小单位,多个线程之间共享进程的代码和数据空间,每一个线程都有自己的程序计数器运行栈,线程之间切换开销较小
        一个cpu同一时刻只能调度一个线程

    线程学习内容:
        线程的概念,优缺点
        创建线程的方式  *****
        线程的状态
        线程安全问题    *****
        线程通信

    创建线程的方式 :
        继承Thread,重写run方法 + start开启线程
        实现Runnable接口,重写run方法 + start开启线程
        实现Callable接口,重写call方法 + 线程池

    继承Thread,重写run方法 + start开启线程
 */
public class Class001_Thread extends Thread{
    /*
        run方法中定义线程体
     */
    @Override
    public void run() {
        for(int i = 1;i<=20;i++){
            System.out.println("一边喝水");
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        //创建一个线程对象
        Class001_Thread th = new Class001_Thread();
        //开启线程
        th.start();

        for(int i = 1;i<=20;i++){
            System.out.println("一边讲课....");
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
通过实现Runnable接口创建线程
/*
    实现Runnable接口,重写run方法+start开启
        优点:
            接口多实现,类的单继承
            实现资源共享

     重写方法对异常抛出的要求:
        重写方法上抛出的异常类型<=被重写方法上异常的抛出类型
 */
public class Class002_Thread implements Runnable{
    public static void main(String[] args) {
        //创建一个线程
        Thread th = new Thread(new Class002_Thread());
        //开启线程
        th.start();

        for(int i = 1;i<=20;i++){
            System.out.println("一边陪女朋友...");
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /*
        定义线程体
     */
    @Override
    public void run() {
        for(int i = 1;i<=20;i++){
            System.out.println("一边打游戏...");
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
内部类实现线程
public class Class006_Thread {

    //静态内部类
    static class Inner implements Runnable{

        @Override
        public void run() {
            for(int i=1;i<=20;i++){
                System.out.println("一边喝水...");
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        //局部内部类
        class Inner2 implements Runnable{

            @Override
            public void run() {
                for(int i=1;i<=20;i++){
                    System.out.println("一边看电影...");
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        new Thread(new Inner()).start();
        new Thread(new Inner2()).start();
        //匿名匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=1;i<=20;i++){
                    System.out.println("一边看吃零食...");
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
        //lambda表达式
        new Thread(()->{
                for(int i=1;i<=20;i++){
                System.out.println("一边看吃吸烟...");
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

线程状态

 线程的状态:
        新生状态 : new
        就绪状态
        运行状态 : cpu调度
        阻塞状态
        终止状态

        一个线程如果一旦进入终止状态,不可恢复
        一个线程如果进入到阻塞状态,阻塞解除之后,不能直接恢复到运行,会直接恢复高就绪状态,等待cpu的调度

        如何让线程进入到就绪状态:
            1.start()
            2.阻塞解除
            3.cpu的调度切换
            4.yield 礼让线程

        如何让线程进入阻塞状态:
            1.sleep()
            2.join() 插队线程
            3.wait() 等待
            4.IO

        如何让线程进入终止状态:
            1.正常执行完毕
            2.stop() 过时--> 不推荐使用
            3.通过标识判断

    sleep 线程休眠
        static void sleep(long millis) 导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数，具体取决于系统计时器和调度程序的精度和准确性。
        static void sleep(long millis, int nanos) 执行ms+ns

        当一个线程调度sleep进入睡眠状态,让出cpu的资源
        抱着资源睡觉: 这个资源不是cpu的资源, 值的是对象的锁资源

        作用:
            放大问题出现的可能性
            模拟网络延迟
            
     Thread.State getState() 获取线程状态

    Thread.State 线程状态。 线程可以处于以下状态之一：
        NEW : new Thread()
        尚未启动的线程处于此状态。
        RUNNABLE : 就绪|运行
        在Java虚拟机中执行的线程处于此状态。
        BLOCKED : 等待对象锁的阻塞状态
        被阻塞等待监视器锁定的线程处于此状态。
        WAITING : wait(),join()等
        无限期等待另一个线程执行特定操作的线程处于此状态。
        TIMED_WAITING : 与时间相关的等待,sleep(ms),join(ms),wait(ms)...
        正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。
        TERMINATED : 终止
        已退出的线程处于此状态。

 yield 礼让线程
     当线程执行到yield方法,会让出cpu的资源,同时线程会恢复就绪状态
 join() 插队线程
        A线程执行过程中,如果B线程插队了,A线程就会进入到阻塞状态,等待插队线程执行完毕|等待执行的时间,A线程会恢复到就绪状态
        void join() 等待这个线程死亡。
        void join(long millis) 此线程最多等待 millis毫秒。
        void join(long millis, int nanos) 此线程最多等待 millis毫秒加上 nanos纳秒。
 void interrupt()  为线程添加一个中断标识
    boolean isInterrupted() 测试此线程是否已被中断,是否曾经调用过interrupt方法添加了中断标识
    static boolean interrupted() 测试当前线程是否已被中断,是否曾经调用过interrupt方法添加了中断标识,同时复位标识
    注意: 当调用sleep方法线程睡眠时 : InterruptedException - 如果有任何线程中断了当前线程。 抛出此异常时，将清除当前线程的中断状态 。

线程优先级与守护线程

 线程的优先级 :
        方法线程优先执行的可能性
        1~10 设置值
            1最小 ->static int MIN_PRIORITY 线程可以拥有的最低优先级。
            10最大->static int MAX_PRIORITY 线程可以拥有的最大优先级。
            5默认值 ->static int NORM_PRIORITY 分配给线程的默认优先级。

        int getPriority() 返回此线程的优先级。
        void setPriority(int newPriority) 更改此线程的优先级。
        
 线程的分类:
       用户线程 : 默认线程为用户线程
       守护线程

    守护线程 : 守护用户线程的
        当所有的用户线程全都执行完毕,守护线程直接结束
        垃圾回收机制典型守护线程
        void setDaemon(boolean on) 将此线程标记为 daemon线程或用户线程。

同步锁

线程安全
线程安全 :
        当多个线程同时操作同一份资源,才有可能出现线程不安全问题

     同步锁 synchronized : 有可能出现数据不安全的代码段,让多个线程排队执行
     同步的使用:
        同步条件 :  协调多个线程排队执行的条件  -->对象的锁
        同步的代码 :  需要多个线程排队执行的代码
     synchronized用法:
        修饰方法 : 同步方法
            同步实例方法
                条件 : 调用成员方法的对象
                代码范围 : 整个方法体
            同步静态方法
                条件 : 锁类->锁的类的Class对象->一个类只有一个,加载到内存中究存在Class对象,不变,唯一
                代码范围 : 整个方法体

        修饰块 : 同步块
           synchronized(条件){
                排队执行的代码;
           }

        注意:
            同步的代码范围太大,效率太低
            同步的代码范围太小,锁不住,不安全
同步方法案例（买票）
/*
    同步方法控制案例的数据安全
        在方法上通过synchronized关键字修饰方法
            成员方法
                锁的是调用成员方法的对象
            静态方法
                锁的是类的Class对象

        优点: 简单,直接同步整个方法体
        缺点: 代码范围太大,效率较低
 */
public class Class002_Web12306 implements Runnable{
    //共享资源 100张票
    int tickets = 100;

    @Override
    public void run() {
        while(true){
            if(!buyTicket()){
                break;
            }
            //方法cpu切换调度的可能性
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //一次购票的过程,每一个线程排队购票
    //返回值 : true-->继续购买  false->结束购买
    public synchronized boolean buyTicket(){
        if(tickets<=0){
            return false;
        }
        /*模拟一次购票的时间*/
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"正在购买第"+tickets--);
        return true;
    }


    public static void main(String[] args) {
        Class002_Web12306 web = new Class002_Web12306();
        //创建线程
        Thread th1 = new Thread(web,"张三");
        Thread th2 = new Thread(web,"李四");
        Thread th3 = new Thread(web,"王五");

        //线程开启
        th1.start();
        th2.start();
        th3.start();
    }
}
同步块案例（买票）
锁类
/*
    同步块 :
        synchronized(条件){
            排队执行的代码;
        }

        条件 : 类名.class | this | 资源

        锁类: 锁类相当于锁住了这个类的所有对象,如果只想要锁当前类的某一个对象,建议锁那一个具体的对象this

 */
public class Class003_Web12306 implements Runnable{
    //共享资源 100张票
    int tickets = 100;

    @Override
    public void run() {
        while(true){
            //同步块-->  锁类
            synchronized (Class003_Web12306.class){
                if(tickets<=0){
                    break;
                }
                /*模拟一次购票的时间*/
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在购买第"+tickets--);
            }
            //方法cpu切换调度的概率
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Class003_Web12306 web = new Class003_Web12306();
        //创建线程
        Thread th1 = new Thread(web,"张三");
        Thread th2 = new Thread(web,"李四");
        Thread th3 = new Thread(web,"王五");

        //线程开启
        th1.start();
        th2.start();
        th3.start();
    }
}
锁对象
/*
    同步块 :
        synchronized(条件){
            排队执行的代码;
        }

        条件 : 类名.class | this | 资源

        锁this: 成员方法中this默认指代当前调用成员方法的对象
                如果锁this,就是锁一个对象,相当于锁住了这个对象的所有资源(成员),如果指向锁一个对象的某一个资源,建议可以直接锁资源

 */
public class Class004_Web12306 implements Runnable{
    //共享资源 100张票
    int tickets = 100;

    @Override
    public void run() {
        while(true){
            //同步块-->  锁类
            synchronized (this){
                if(tickets<=0){
                    break;
                }
                /*模拟一次购票的时间*/
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在购买第"+tickets--);
            }
            //方法cpu切换调度的概率
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Class004_Web12306 web = new Class004_Web12306();
        //创建线程
        Thread th1 = new Thread(web,"张三");
        Thread th2 = new Thread(web,"李四");
        Thread th3 = new Thread(web,"王五");

        //线程开启
        th1.start();
        th2.start();
        th3.start();
    }
}
锁资源
/*
    同步块 :
        synchronized(条件){
            排队执行的代码;
        }

        条件 : 类名.class | this | 资源

        锁资源 :  锁对象,锁不变的内容
                  自定义引用数据类型的对象地址永远不变

 */
public class Class005_Web12306 implements Runnable{
    //共享资源 100张票
    Tickets tickets = new Tickets();

    @Override
    public void run() {
        while(true){
            //同步块-->  锁资源
            synchronized (tickets){
                if(tickets.num<=0){
                    break;
                }
                /*模拟一次购票的时间*/
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在购买第"+tickets.num--);
            }
            //方法cpu切换调度的概率
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Class005_Web12306 web = new Class005_Web12306();
        //创建线程
        Thread th1 = new Thread(new Class005_Web12306(),"张三");
        Thread th2 = new Thread(new Class005_Web12306(),"李四");
        Thread th3 = new Thread(new Class005_Web12306(),"王五");

        //线程开启
        th1.start();
        th2.start();
        th3.start();
    }
}

//票
class Tickets{
    int num = 100;
}
秃子传奇
关注
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
java 多线程“同步锁”
weixin_45255645的博客
09-26 265
什么是多线程同步： 多个线程之间共享同一个资源。如果没有同步的话，多个线程就会出现异步，争CPU资源会出现数据错误，导致线程并发。有了同步后，可以实现数据的正确性。 同步锁： 同步锁中锁的是对象，不是方法或者是代码块。只有当一个线程停止时，另外一个线程才可以进入。这样可以保证数据同步，不会出现异步的情况。 同步方法： synchronized关键字修饰的方法 public synchronized static boolean lock(){ boolean flag = fa
Java线程：线程的同步与锁
蜜蜂的专栏
05-30 263
一、同步问题 线程的同步是为了防止多个线程访问一个数据对象时，对数据造成的破坏。   如果要保持结果的合理性，只需要达到一个目的，就是将对同一个对象的访问加以限制，每次只能有一个线程在访问。这样就能保证Foo对象中数据的合理性了。   在具体的Java代码中需要完成一下两个操作： 把竞争访问的资源类Foo变量x标识为private； 同步哪些修改变量的代码，使用synchronize
第十九天笔记
qq_64619157的博客
03-25 116
多线程: 多任务执行,多路径执行 优点: 提高性能 提高效率 进程与线程之间的区别: 进程 : 系统中的程序,一个进程之间可以包含1~n个线程,系统中资源分配的最小单位,每个进程都有自己的代码与数据空间,进程之间的切换开销较大 线程 : 程序中的顺序流,线程是cpu调度与执行的最小单位,多个线程之间共享进程的代码和数据空间,每一个线程都有自己的程序计数器运行栈,线程之间切换开销较小 一个cpu同一时刻只能调度一个线程 线程学习内容: 线程的概念,优缺点 .
java多线程——同步与锁
Levi_moon的博客
06-05 576
一、线程同步 java多线程的同步是为了防止多个线程对数据对象进行操作时，损坏数据。 那么什么时候用到同步呢？在多个线程同时访问互斥（可交换）数据时，应该同步以保护数据，确保两个线程不会同时修改更改它。 那什么叫同步方法呢？当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。 比如： 银行里有一1000元钱，有两个人同时取900元，来模拟线程的同步。 public
Java多线程知识点总结
08-19
总之，掌握Java多线程的生命周期、创建、启动、同步以及线程池的使用是编写高效、稳定并发程序的基础。理解这些知识点对于解决并发编程中的问题，比如资源竞争、死锁、线程安全性等问题，至关重要。在实际开发中，...
Java基础之多线程
08-26
以下是对Java多线程基础知识点的详细解释： 1. **线程启动与执行**： - `start()` 方法用于启动线程，将线程放入操作系统的线程队列等待CPU调度执行，调用后会自动执行`run()` 方法。 - `run()` 方法是线程的主要...
并发编程基础知识，java内存模型及多线程、volatile
最新发布
04-29
### 并发编程基础知识，Java内存模型及多线程、volatile #### Java内存模型(JMM) Java内存模型（Java Memory Model, JMM）是Java并发编程的基础之一，它定义了一套规则来保证线程之间的数据可见性和一致性。当程序...
java基础之多线程讲解
04-09
### Java基础之多线程讲解 #### 一、进程与线程的概念 - **进程**：进程是系统进行资源分配和调度的基本单位，是应用程序运行时的实例。一个进程中可以包含一个或多个线程。 - **线程**：线程是进程中的实际运作...
java多线程（同步锁-lock）
weixin_59796310的博客
06-08 226
java多线程（同步锁-lock）
java多线程 线程同步安全问题 同步锁
weixin_56564088的博客
03-17 222
Java线程安全问题
Java多线程 同步 锁 条件对象
WEBCODE
07-26 102
每个进程都有它自己的变量的完备集，线程共享相同的数据。---这也是危险之处。 线程创建和销毁的开销都比进程小。---这是好处。 简单的，你只要实现Runnable接口，实现重载run()方法，来做自己想做的事情。然后就是开启一个线程，把你实现的类的对象传入： Runnable r = new myRunable(args[] a); Thread t = new Thread(r); t.sta...
多线程开发--同步锁
冰点契约的博客
06-29 228
同步锁 同步就是协同步调，按预定的先后次序进行运行。如:你说完，我再说。"同"字从字面上容易理解为一起动作，其实不是，"同"字应是指协同、协助、互相配合。 如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行;B依言执行，再将结果给A;A再继续操作。这既是同步 python对线程加锁主要有Lock和Rlock模块 注意： 加锁还可以使用with 效果一样 必须使用同一把锁 如果使用锁，程序会变成串行，因此应该是在适当的地方加锁 线程调度本质上是不
Java多线程（九）线程同步和锁
大鱼的博客
03-18 1135
前言 前面的文章介绍了并发的情况下会有数据错误的现象出现。 并发：同一个对象被多个线程同时操作，也就是不同线程同时操作同一个资源地址，造成数据紊乱。 同步：多个需要同时访问资源的线程进入对象的等待池，等待前面线程使用完毕。 锁：每个对象都有把锁，当获取对象时，独占资源，其他线程必须等待，使用结束后才释放 一个线程持有锁会导致其他所有需要此锁的线程挂起 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性
Java笔记-多线程中同步加锁相关
IT1995的博客
12-30 5240
Java程序入口就是由JVM启动的main线程： main线程又可以启动其他线程。当所有线程都运行结束时JVM退出，进程结束。 守护线程（Daemon）：守护线程是为其他线程服务的线程，所有的非守护线程都执行完毕后，虚拟机才会退出。 守护线程的特点：不能持有资源（如打开文件等） 创建守护线程： setDaemon(true); 下面来演示下，子线程中有死循环，而主线程退出...
java多线程--同步锁、
在路上
10-09 1247
同步代码块: 语法: synchronized(同步锁) {      需要同步操作的代码 } --------------------------------------------------- 同步锁: 为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制. 同步监听对象/同步锁/同步监听器/互斥锁: 对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁....
java多线程之同步锁（Lock）
翻过一座座山
08-12 732
      从Java5开始，提供了Lock， Lock提供了比synchronized方法和synchronized代码块更广泛的锁定操作，Lock可以实现更灵活的结构，并且支持多个相关的Condition对象(对象监视器)。       Lock是控制多个线程对共享资源进行访问的工具。通常，锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得L...
Java 多线程同步锁
weixin_39413778的博客
07-18 180
需求是这样的，需要两个线程同时操作 一个对象的成员变量，让其按照 1 0 1 0 1 0 1 0 1 0 1 0 这样的格式进行输出 public class MyObject { private int count; public synchronized void increase(){ if(count == 1){ try { wait(); } catch (InterruptedException e) { // TODO Auto-generated cat
Java多线程基础与同步技术详解
4. **多线程同步** 同步是为了避免多个线程并发访问共享资源导致的数据不一致。主要有两种同步方式： - **同步代码块**：使用`synchronized`关键字包围代码，锁对象可以是任何对象。只有一个线程可以获得锁并执行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值