Java中的线程的状态、线程休眠、同步锁、死锁、Lock接口、匿名内部类(基础解析)

最新推荐文章于 2021-02-13 17:54:48 发布
最新推荐文章于 2021-02-13 17:54:48 发布
阅读量668 收藏
点赞数
分类专栏： Java 文章标签： java 线程 同步锁 Lock接口 匿名内部类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ssssssue/article/details/79274333
版权 
    创建一个线程 相当于CPU开辟了一个独立的执行路径
    每个执行路径都是一个独立的空间
    创建一个线程 该线程就会拥有一个独立的栈空间
    如果在同一个栈空间中 不符合先入栈后出栈规则
    线程的六种状态
        1.新建状态(new 线程对象)
        2.运行状态(调用 start方法)
        3.受阻塞状态(等待CPU的执行资源)
        4.休眠状态(调用了sleep(时间)方法)
        5.等待状态(调用了wait方法)
        6.死亡状态(润方法执行完毕)

线程的状态图

匿名内部类

    相当于创建一个该类的子类的对象
    new 父类类名或接口名(){
        重写父类的方法
    };
    public class Demo {
        public static void main(String[] args){
            // 创建Test类的子类对象
            // 这里可以直接new Test(){}
            // 但是这样这个对象没有名字 是匿名对象
            // 可以接收一下
            Test test = new Test(){
                //重写父类的方法
                @Override
                public void fun(){
                    System.out.println("我是子类的fun方法");
                }
            };
            // 调用子类方法
            test.fun();
        }
    }

    class Test{
        public void fun(){
            System.out.println("我是父类的fun方法");
        }
    }
    public class Demo {
         public static void main(String[] args) {
             // 创建接口的实现类
             new TestInter() {
                 @Override
                 public void fun(){
                     System.out.println("我是实现类的 fun方法");
                 }
             }.fun();
         }
    }

    interface TestInter {
        public abstract void fun();
    }
匿名内部类方式创建线程
    方式1
    public class Demo {
        public static void main(String[] args) {
            new Thread() {
                @Override
                public void run() {
                    System.out.println("我是创建线程方式1");
                }
            }.start();

            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    System.out.println("我是创建线程方式2");
                }
            };
            //放入线程对象中
            Thread thread = new Thread(runnable);
            thread.start();

            new Thread(new Runnable() {
                @Override
                public void run(){
                    System.out.println("我是创建线程方式3");
                }
            }).start();
        }
    }

线程休眠

    public class Demo {
        public static void main(String[] args) throws InterruptedException {
            SleepThread sleepThread = new SleepThread();
            sleepThread.start();
            for (int i = 0; i < 100; i++) {
                // 线程休眠1s 单位是 毫秒
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }
    class SleepThread extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 50; i++) {
                // 休眠1s
                // 如果在子线程中出现异常 只能try...catch处理
                /*
                 * Thread类是Runnable接口的实现类
                 * 重写了接口中的run方法
                 * 该方法 没有抛出异常
                 * 所以 所有Runnable接口的实现类(包括Thread类)
                 * 都不能在run方法中 抛出异常 只能处理
                 */
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }

同步锁

    /*
     * 卖火车票问题
     */
    public class Demo05 {
        public static void main(String[] args) {
            TicketsRunnable tr = new TicketsRunnable();
            // 创建3个线程 这个线程 会执行run方法(这个线程的任务)
            Thread t1 = new Thread(tr);
            Thread t2 = new Thread(tr);
            Thread t3 = new Thread(tr);
            // 开启这三个线程
            t1.start();
            t2.start();
            t3.start();
        }
    }

/*
 * 同步锁(同步代码块)
 * 锁 可以是任意对象  要保证 锁的唯一 三个线程都使用的是同一把锁
 * 
 * 
 * synchronized (对象锁) {

            }
 */
    class TicketsRunnable implements Runnable{
        //声明50张票 保证票是共享数据 只new 一次该类对象
        private int tickets = 50;
        // 创建了对象锁 保证唯一
        private Object obj = new Object();

        //卖票方法
        @Override
        public void run() {
            while (true) {
                // 锁只要保证是对象和唯一 就可以 (填this也可以)
                synchronized (obj) {
                    // 操作的共享数据的代码
                    if (tickets > 0) {
                        // 线程休眠一会儿
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        // 有票就卖一张
                        System.out.println(Thread.currentThread().getName() + "--" + tickets);
                        // 减少一张
                        tickets--;
                    }else {
                        // 没票 结束循环
                        break;
                    }
                }
                // 让线程 让出CPU的资源
                // 不是一定让出 有几率
                Thread.yield();

            }
        }
    }
方法中添加 synchronized 关键词
    *
    * 同步锁规则:  
    *   如果有锁 可以进同步代码块 携带锁进去 
    *   当线程执行完同步代码块中的代码 把锁还回去
    *   如果没有锁 线程需要在同步代码块外等待 遇到锁才可以近同步代码块             
    */
    public class Demo06 {
        public static void main(String[] args) {
            TicketsRunnable1 tr1 = new TicketsRunnable1();
            // 创建3个线程 这个线程 会执行run方法(这个线程的任务)
            Thread t1 = new Thread(tr1);
            Thread t2 = new Thread(tr1);
            Thread t3 = new Thread(tr1);
            // 开启这三个线程
            t1.start();
            t2.start();
            t3.start();
        }
    }

    class TicketsRunnable1 implements Runnable {
        // 声明50张票 保证票是共享数据 只new 一次该类对象
        private int tickets = 50;
        // 创建了对象锁 保证唯一
        private Object obj = new Object();

        // 卖票方法
        @Override
        public void run() {
            while (true) {
                if (sellTickets()) {
                    break;
                }
                // 让出CPU资源
                Thread.yield();
            }
        }

        // 操作共享数据的方法
        // 在方法中 添加 synchronized 关键词
        public synchronized boolean sellTickets() {

            // 操作的共享数据的代码
            if (tickets > 0) {
                // 线程休眠一会儿
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                // 有票就卖一张
                System.out.println(Thread.currentThread().getName() + "--" + tickets);
                // 减少一张
                tickets--;
                return false;
            } else {
                // 没票 结束循环
                return true;
            }
        }
    }
静态的同步代的码锁
    public class Demo06 {
    public static void main(String[] args) {
        TicketsRunnable1 tr1 = new TicketsRunnable1();
        // 创建3个线程 这个线程 会执行run方法(这个线程的任务)
        Thread t1 = new Thread(tr1);
        Thread t2 = new Thread(tr1);
        Thread t3 = new Thread(tr1);
        // 开启这三个线程
        t1.start();
        t2.start();
        t3.start();
    }
}

class TicketsRunnable1 implements Runnable {
    // 声明50张票 保证票是共享数据 只new 一次该类对象
     private static int tickets = 50;
    // 创建了对象锁 保证唯一
    private Object obj = new Object();

    // 卖票方法
    @Override
    public void run() {
        while (true) {
            if (sellTickets()) {
                break;
            }
            // 让出CPU资源
            Thread.yield();
        }
    }


     //静态方法的同步代码的锁 可以使用本类 类名.class
     public static boolean sellTickets() {
        synchronized (TicketsRunnable1.class) {
        // 操作的共享数据的代码
            if (tickets > 0) {
            // 线程休眠一会儿
            try {
                Thread.sleep(10);
                 } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
                 }
             // 有票就卖一张
             System.out.println(Thread.currentThread().getName() + "--" + tickets);
            // 减少一张
             tickets--;
             return false;
             } else {
            // 没票 结束循环
            return true;
             }
         }
     }
}
死锁
    /*
     * 模拟线程死锁
    * 1.需要两个锁对象( 保证唯一)
     */
    public class Demo07 {
        public static void main(String[] args) {
            DeathLockRunnable dlr = new DeathLockRunnable();
            Thread t1 = new Thread(dlr);
            Thread t2 = new Thread(dlr);
            t1.start();
            t2.start();
        }
    }
    // A锁
    class LockA {
        // 私有构造方法
        private LockA() {

        }
        // 定义一个常量 作为 锁对象 不能修改 也不能创建
        public static final LockA LOCK_A = new LockA();
    }
    // B锁
    class LockB{
        //私有构造方法
        private LockB() {

        }
        // 定义一个常量 作为 锁对象 不能修改 也不能创建
        public static final LockB LOCK_B = new LockB();
    }

    class DeathLockRunnable implements Runnable{
        // 声明一个标识
        // 标记一次是先A后B
        //    一次是先B后A
        private boolean isTrue = true;
        @Override
        public void run() {
            // 死循环(增加死锁的几率)
            while (true) {
                if (isTrue) {
                    // A --> B
                    synchronized (LockA.LOCK_A) {
                        System.out.println("if...LOCK_A");
                        synchronized (LockB.LOCK_B) {
                            System.out.println("if...LOCK_B");
                        }
                    }
                } else {
                    // B --> A
                    synchronized (LockB.LOCK_B) {
                        System.out.println("else...LOCK_B");
                        synchronized (LockA.LOCK_A) {
                            System.out.println("else...LOCK_A");
                        }
                    }
                }
                // 修改标记
                isTrue = !isTrue;
            }
        }
    }

Lock 接口

    Lock 是jdk1.5之后出现的锁
    使用Lock锁
    Lock.lock();
    try{
        写操作共享数据的代码
    }finally{
        lock.unlock();
    }
    public class Demo {
        public static void main(String[] args) {
            Tickets3 tickets3 = new Tickets3();
            Thread t1 = new Thread(tickets3);
            Thread t2 = new Thread(tickets3);
            Thread t3 = new Thread(tickets3);
            t1.start();
            t2.start();
            t3.start();
        }
    }
    class Tickets3 implements Runnable{
        private int tickets = 50;
        //声明锁对象
        private ReentrantLock lock = new ReentrantLock();
        @Override
        public void run() {
            while (true) {
                // 加锁
                lock.lock();
                try {
                    // 锁住操作共享数据的代码
                    if (tickets > 0) {
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + ":" + tickets);
                        tickets--;
                    }else {
                        break;
                    }
                } finally {
                    // 解锁
                    lock.unlock();
                }
                // 让出CPU资源
                Thread.yield();
            }
        }
    }

接口实现创建线程的好处

    1.避免直接集成Thread类的局限性(避免单继承)
    2.接口即插即用 减少类与类之间联系(可以解耦)


                                        Day.29

http://blog.csdn.net/ssssssue

稳健de少年
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程Runnable匿名内部类一定要注意大坑
憨人啊的博客
09-28 9952
通常情况下，当需要模拟多线程的时候我们会选择两种方式。第一种就是自己实现Runnable类，然后在主类中调用我们自己实现的Runnable，例如： package concurrent; public class MyRunnable implements Runnable{ @Override public void run() { // TODO Auto-generated ...
创建线程的三种方式 线程的常用方法。线程的Sleep阻塞
szl7369的博客
07-09 579
什么是进程？ 正在运行的程序 什么是线程？ 进程中，多个独立的小的执行单位 进程中，至少有一个前置/前台线程 CPU执行线程，感官上是同时，但是同一时间，只执行一个线程 切换速度很快，所以感觉上是同时（CPU的切换是随机的） 实现多线程 Thread ：3种方式 1.继承Thread类，实现run方法 -> new MyThread() 2.实现Runnable接口，实现run方法 -&...
同步锁--sleep,wait,lock,synchronized
aizhuanjiao110的专栏
08-20 470
package com.java.test; public class Test5 { /** * Java多线程实现有两种实现方法，分别是继承Thread类，重写run()方法与实现Runnable接口 *sleep与wait区别： * sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监 * 控状态依然保持，到时后会自动
java多线程（2）---睡眠与同步锁
SUDALYL的专栏
12-15 246
    昨天讲到了如何实现多线程以及多线程的好处，今天我们来看看线程的睡眠sleep()，多线程问题，sleep()是一个静态方法，以毫秒为为单位，我们为什么要使用睡眠呢？那当然是为了我们宝贵的CPU资源能在短时间内为更多的线程服务，而不是在某段时间内一直被某个线程占用。比如某线程在等待一个资源，这个时候我们通常让此线程先阻塞一会，一段时间后继续进入可运行状态，此时如果线程获得了所需的资源则可以继...
java线程池中锁机制_Java多线程总结（二）锁、线程池
weixin_31083103的博客
02-13 568
本文转载地址：一、Java中锁什么是锁。锁就是为了保护资源，防止多个线程同时操作资源时出错的机制。我们先来看一下锁的类图：如图，Java中的锁有两个主要的根接口——Lock和ReadWriteLock，分别表示锁和读写锁。其中Lock的主要实现类是ReetrantLock。ReadWriteLock的主要实现类是ReetrantReadWriteLock。而ReetrantReadWriteLoc...
Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
最新发布
02-02
Java多线程--避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
Java线程之锁对象Lock-同步问题更完美的处理方式代码实例
08-28
Java线程之锁对象Lock-同步问题更完美的处理方式代码实例 Java中的锁对象Lock是java.util.concurrent.locks包下的接口，提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。它能以更优雅的方式处理线程...
深入解析Java并发程序中线程的同步与线程锁的使用
09-02
在Java中，`synchronized`关键字和`Lock`接口是实现线程同步的常见方式，它们主要用于解决多线程环境下的数据一致性问题，防止数据的不一致性和竞态条件。 `synchronized`关键字是Java内置的同步机制，它提供了两种...
Java多线程 线程同步与死锁
08-30
在Java中，有多种方法可以实现线程同步，例如使用synchronized关键字、Lock接口、Atomic变量等。在多线程编程时，需要根据实际情况选择合适的同步方法，以避免线程安全问题的出现。 另外，死锁是指多个线程之间的...
Java多线程-线程的同步与锁的问题
09-01
Java多线程编程中，线程同步是一种解决并发问题的关键技术。当多个线程同时访问共享资源时，可能会引发数据不一致性和竞态条件。线程同步的主要目标是确保同一时间只有一个线程能够访问特定的代码段，以避免数据损坏...
java-tryLock可轮询可中断可定时的锁
深未来技术
02-21 508
1、从JAVA5.0开始,提供了新的选择:ReentrantLock。 2、可定时和可轮询的锁获取模式由tryLock方法实现。 3、使用tryLock试图获得的锁如果不能同时获得，就回退，并重新尝试。休眠时间由一个特定组件管理。（下面的代码完成转帐） public boolean transferMoney(Account fromAcct,AccounttoAcct,DollarAm...
【java】匿名内部类和多线程
XiaoChen~Coder
08-15 536
匿名内部类和多线程1. 匿名内部类1.1 接口你还记得吗???1.2 类的本体2. 多线程2.1 什么是进程2.2 什么是线程2.3 线程和进程的关系2.4 线程优缺点2.5 Java中创建线程的两种方式【low】2.6 Thread中常用方法2.7 线程锁操作问题2.7.1 生活场景分析2.7.2 代码实现分析2.7.3 售票抢占问题2.7.4 同步代码块2.8 守护线程/后台线程 匿名内部类和多线程) 1. 匿名内部类 1.1 接口你还记得吗??? interface A { 成员变量
java trylock超时_java trylock以及可中断锁
weixin_30663839的博客
02-13 1456
线程在调用lock方法来获得另一个线程所持有的锁的时候，很可能发生阻塞。应该更加谨慎地申请锁。tryLock方法试图申请一个锁，在成功获得锁后返回true,否则，立即返回false，而且线程可以立即离开去做其他事。可以调用tryLock时，使用超时参数。lock方法不能被中断。如果一个线程在等待获得一个锁时被中断，中断线程在获得锁之前一直处于阻塞状态。如果出现死锁，那么，lock方法就无法终止。A...
线程的死锁和死锁解决的实际案例
编程爱好者
09-16 2731
面试线程还是大头，不能有一丝一毫的模糊。 先来看死锁：就是多个锁和多个线程之间发生的故事，这里以俩个锁和俩个线程为例子。 锁1、锁2、线程1、线程2 当线程1获取锁1之后，线程2也获取了锁2，这是线程1又开始获取锁2（嵌套获取），线程2又想获取锁1（嵌套1获取），这种情况下线程1会等着线程2释放锁2，线程2会等着线程1释放锁1，然后就会形成了死锁。 具体代码： public class...
线程进入sleep状态，如果加锁，锁不会释放，其他线程无法进入Rum.
有志者事竟成
08-02 5125
线程进入sleep状态，如果加锁，锁不会释放，其他线程无法进入Rum. package com.yuxin.learn; import java.io.IOException; import java.util.Scanner; public class Main { public static void main(String[] args) throws IOExceptio

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值