java笔记（多线程+Runnable接口)-第22天

最新推荐文章于 2022-11-24 21:52:01 发布
最新推荐文章于 2022-11-24 21:52:01 发布
阅读量402 收藏 1
点赞数
分类专栏： java学习笔记 文章标签： java学习笔记 java多线程 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dianziagen/article/details/48577889
版权

创建线程方式二：实现Runnable接口

 

1. 定义类实现Runnable接口。
    2.覆盖接口中的run方法，将线程的任务代码封装到run方法中。
    3. 通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。为什么？

因为线程的任务都封装在Runnable接口子类对象的run方法中。

所以要在线程对象创建时就必须明确要运行的任务。
    4. 调用线程对象的start方法开启线程。

    实现Runnable接口的好处：
    1. 将线程的任务从线程的子类中分离出来，进行了单独的封装，

按照面向对象的思想将任务封装成对象。
    2. 避免了Java单继承的局限性。所以，创建线程的第二种方式较为常用。

 

线程都有自己默认的名称。即：thread-编号。编号从0开始。

 

    示例：

1.  //准备扩展Demo类的功能，让其中的内容可以作为线程的任务执行。

2.  //通过接口的形式完成。

public class One {
    public static void main(String[] args) {
        Demo demo = new Demo();
        Thread t1 = new Thread(demo);
        Thread t2 = new Thread(demo);
        t1.start();
        t2.start();
//        Thread-1...0
//        Thread-1...1
//        Thread-0...0
//        Thread-0...1
    }
}

class Demo implements Runnable {

    @Override
    public void run() {
        show();
    }

    private void show() {
        for (int x = 0; x < 8; x++) {
            // currentThread()返回对当前正在执行的线程对象的引用。
            //返回该线程的名称。getName()
            System.out.println(Thread.currentThread().getName() + "..." + x);

        }
    }
}

   

5.2线程安全问题

 

    5.2.1 线程安全问题产生的原因

 

    需求：模拟4个线程同时卖100张票。

 

    代码：

public class One {
    public static void main(String[] args) {
        Ticket t = new Ticket();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        Thread t4 = new Thread(t);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

class Ticket implements Runnable {
    private int num = 100;

    @Override
    public void run() {
        while (true) {
            if (num > 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "...sale..." + num--);
            }
        }
    }
}

   运行结果：(最后几行的日志)

Thread-3...sale...2
Thread-1...sale...1
Thread-0...sale...0
Thread-3...sale...-2
Thread-2...sale...-1


    原因分析：
    出现上图安全问题的原因在于Thread-0通过了if判断后，在执行到“num--”语句之前，

num此时仍等于1。    CPU切换到Thread-1、Thread-2、Thread-3之后，这些线程依然可以通过if判断，从而执行“num--”的操作，因而出现了0、-1、-2的情况。
    

线程安全问题产生的原因：
    1. 多个线程在操作共享的数据。
    2. 操作共享数据的线程代码有多条。

当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就会导致线程安全问题的产生。

    5.2.2 线程安全问题的解决方案

   思路：
    就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程不可以参与运算。必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算。

    在java中，用同步代码块就可以解决这个问题。将共享数据的线程代码封装。

    同步代码块的格式：

    synchronized(对象){

          需要被同步的代码;
    } 

    同步的好处：解决了线程的安全问题。
    同步的弊端：当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。
    同步的前提：必须有多个线程并使用同一个锁。

    修改后代码：
 

class Ticket implements Runnable {
    private int num = 100;
    Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if (num > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "...sale..." + num--);
                }
            }
        }
    }
}

   运行结果：（最后几行日志）
Thread-3...sale...3
Thread-3...sale...2
Thread-3...sale...1

 

原因分析：
   上图显示安全问题已被解决，原因在于Object对象相当于是一把锁，只有抢到锁的线程，才能进入同步代码块向下执行。

因此，当num=1时，CPU切换到某个线程后，如上图的Thread-3线程，其他线程将无法通过同步代码块继而进行if判断语句，只有等到Thread-3线程执行完“num--”操作（此后num的值为0），并且跳出同步代码块后，才能抢到锁。其他线程即使抢到锁，然而，此时num值已为0，也就无法通过if语句判断，从而无法再执行“num--”的操作了，也就不会出现0、-1、-2等情况了。

 

    利用同步代码块解决安全问题案例：

   需求：储户，两个，每个都到银行存钱，每次存100，共存三次。

   代码：

public class One {
    public static void main(String[] args) {
        Cus c = new Cus();
        Thread t1 = new Thread(c);
        Thread t2 = new Thread(c);
        t1.start();
        t2.start();
    }
}

class Bank {
    private int sum;

    public void add(int num) {
        synchronized (this) {//同步函数，默认this
        sum = sum + num;
        System.out.println("sum =" + sum);
        }
    }
}

class Cus implements Runnable {
    private Bank b = new Bank();//创建bank类

    @Override
    public void run() {
        for (int x = 0; x < 3; x++) {
            b.add(100);
        }
    }
}

   运行结果：

sum =100
sum =200
sum =300
sum =400
sum =500
sum =600

 

    原因分析：
   由如下代码中可以看到，同步代码块中的语句，存在可能有多个线程同时操作共享数据（sum）的情况，通过同步代码块即可解决存在的安全问题。


  如果不设置同步代码块，出现的结果如下：

sum =200
sum =200
sum =300
sum =400
sum =500
sum =600

 

安全问题的另一种解决方案：同步代码块

   格式：在函数上加上synchronized修饰符即可。

   示例：

class Bank {
    private int sum;

    public synchronized void add(int num) {
        sum = sum + num;
        System.out.println("sum =" + sum);
    }
}

   运行结果：

sum =100
sum =200
sum =300
sum =400
sum =500
sum =600

 

同步函数和同步代码块的区别：

   1. 同步函数的锁是固定的this。

    2. 同步代码块的锁是任意的对象。 建议使用同步代码块。

 

    由于同步函数的锁是固定的this，同步代码块的锁是任意的对象，那么如果同步函数和同步代码块都使用this作为锁，就可以实现同步。

 

    示例：

public class One {
    public static void main(String[] args) {
        Ticket t = new Ticket();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);

        t1.start();
        //下面这条语句一定要执行。因为可能线程t1尚未真正启动，flag已经设置为false，那么当t1执行的时候，就会按照flag为false的情况执行，
        // 线程t2也按照flag为false的情况执行，实验就达不到目的了。
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t.flag = false;
        t2.start();
    }
}

class Ticket implements Runnable {
    private int num = 10;
    boolean flag = true;

    @Override
    public void run() {
        if (flag) {
            while (true) {
                synchronized (this) {//同步函数使用this作为锁
                    if (num > 0) {
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "...sale..." + num--);
                    }
                }
            }
        } else {
            while (true)
                show();
        }
    }

    //同步代码块
    public synchronized void show() {
        if (num > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "...function..." + num--);
        }
    }
}

   运行结果：

Thread-0...sale...10
Thread-0...sale...9
Thread-0...sale...8
Thread-0...sale...7
Thread-0...sale...6
Thread-0...sale...5
Thread-0...sale...4
Thread-1...function...3
Thread-1...function...2
Thread-1...function...1

    静态的同步函数使用的锁是该函数所属字节码文件对象，可以用getClass方法获取，也可以用当前类名.class表示。

    示例：

class Ticket implements Runnable {
    private static int num = 15;
    boolean flag = true;

    @Override
    public void run() {
        if (flag) {
            while (true) {
                synchronized (Ticket.class) {
                    if (num > 0) {
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "...sale..." + num--);
                    }
                }
            }
        } else {
            while (true)
                show();
        }
    }

    //同步代码块
    public static synchronized void show() {
        if (num > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "...function..." + num--);
        }
    }
}

   运行结果：

Thread-0...sale...15
Thread-0...sale...14
Thread-0...sale...13
Thread-0...sale...12
Thread-0...sale...11
Thread-0...sale...10
Thread-0...sale...9
Thread-0...sale...8
Thread-0...sale...7
Thread-0...sale...6
Thread-0...sale...5
Thread-0...sale...4
Thread-0...sale...3
Thread-0...sale...2
Thread-0...sale...1

 

5.2.3 多线程下的单例模式

 

    饿汉式：

class Single{
    private static final Single s = new Single();
    private Single(){}
    public static Single getInstance(){
        return s;
    }
}

    P.S.
   饿汉式不存在安全问题，因为不存在多个线程共同操作数据的情况。

    懒汉式：

class Single {
    private static Single s = null;

    private Single() {
    }

    public static Single getInstance() {
        if (s == null) {
            synchronized (Single.class) {
                //进入同步锁后，再次判断是否已经创建了对象
                if (s == null) {
                    s = new Single();
                }
            }
        }
        return s;
    }
}

    P.S.

    懒汉式存在安全问题，可以使用同步函数解决。

    但若直接使用同步函数，则效率较低，因为每次都需要判断。

    但若采取如下方式，即可提升效率。

    原因在于任何一个线程在执行到第一个if判断语句时，如果Single对象已经创建，则直接获取即可，而不用判断是否能够获取锁，相对于上面使用同步函数的方法就提升了效率。如果当前线程发现Single对象尚未创建，则再判断是否能够获取锁。

   1. 如果能够获取锁，那么就通过第二个if判断语句判断是否需要创建Single对象。因为可能当此线程获取到锁之前，已经有一个线程创建完Single对象，并且放弃了锁。此时它便没有必要再去创建，可以直接跳出同步代码块，放弃锁，获取Single对象即可。如果有必要，则再创建。

    2. 如果不能获取到锁，则等待，直至能够获取到锁为止，再按步骤一执行。

 

5.2.4 死锁示例

 

死锁常见情景之一：同步的嵌套。

    示例1：

public class One {
    public static void main(String[] args) {
        Ticket t = new Ticket();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);

        t1.start();
        //下面这条语句一定要执行。因为可能线程t1尚未真正启动，flag已经设置为false，那么当t1执行的时候，就会按照flag为false的情况执行，
        // 线程t2也按照flag为false的情况执行，实验就达不到目的了。
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t.flag = false;
        t2.start();
    }
}

class Ticket implements Runnable {
    private static int num = 110;
    Object obj = new Object();
    boolean flag = true;

    @Override
    public void run() {
        if (flag) {
            while (true) {
//                run方法中的同步函数需要获取obj对象锁
                synchronized (obj) {
                    show();
                }
            }
        } else {
            while (true)
                show();
        }
    }

    //执行代码块show方法则必须获取this对象锁
    public synchronized void show() {
        synchronized (obj) {
            if (num > 0) {
            }
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "...function..." + num--);
        }
    }
}

   运行结果：

Thread-0...function...110


    原因分析：
   由上图可以看到程序已经被锁死，无法向下执行。


1由下图代码可以看到，run方法中的同步函数需要获取obj对象锁，才能执行代码块中的show方法。
2而执行show方法则必须获取this对象锁，然后才能执行其中的同步代码块。

3当线程t1获取到obj对象锁执行同步代码块，

4线程t2获取到this对象锁执行show方法。

5同步代码块中的show方法因无法获取到this对象锁无法执行，show方法中的同步代码块因无法获取到obj对象锁无法执行，就会产生死锁。


简言之，t1拿到了obj锁，同时t2拿到了this锁，然后t1拿不到this锁，执行中止


示例2：

public class One {
    public static void main(String[] args) {
        Test a = new Test(true);
        Test b = new Test(false);
        Thread t1 = new Thread(a);
        Thread t2 = new Thread(b);

        t1.start();
        t2.start();
    }
}

class Test implements Runnable {
    private boolean flag;

    Test(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        if (flag) {
            while (true) {
                synchronized (MyLock.locka) {
                    System.out.println(Thread.currentThread().getName() + "...if locka...");
                    synchronized (MyLock.lockb) {
                        System.out.println(Thread.currentThread().getName() + "...if lockb...");
                    }
                }
            }
        } else {
            synchronized (MyLock.lockb) {
                System.out.println(Thread.currentThread().getName() + "...if lockb...");
                synchronized (MyLock.locka) {
                    System.out.println(Thread.currentThread().getName() + "...if locka...");
                }
            }
        }
    }
}

class MyLock {
    public static final Object locka = new Object();
    public static final Object lockb = new Object();
}

   运行结果：

Thread-0...if locka...
Thread-1...if lockb...

 

分析：

t1拿到locka锁，t2拿到lockb锁，程序终止。

 

 

 

王竹根
关注
专栏目录
解决SpringBoot2多线程无法注入的问题
09-07
主要介绍了解决SpringBoot2多线程无法注入的问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
【JavaSE】Java线程
qinjilll的博客
12-20 272
Java的多线程、定时器的理解与应用、并发与并行的理解、六种线程状态
java多线程实现runnable_Java多线程实现Runnable方式
weixin_42151036的博客
02-13 1764
本文为大家分享了Java多线程实现Runnable方式的具体方法，供大家参考，具体内容如下(一)步骤1.定义实现Runnable接口2.覆盖Runnable接口中的run方法，将线程要运行的代码存放在run方法中。3.通过Thread类建立线程对象。4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。为什么要讲Runnable接口的子类对象传递给Thread的构造方法。...
java Runnable实现线程方式中 通过Thread获取当前线程名称
weixin_45966674的博客
11-24 1286
我们会习惯用getName 给线程定义名字 但用了你会发现 Runnable里是没有这个方法的。因为你是通过 接口实现的 跟Thread类没有关系 自然拿不到 Thread类中的方法。观看本文 需要能通过 Runnable接口实现线程。不过 你要是真的想用 可以通过Thread实现。然后我们实例化时 改一下代码 这次要两个参数。后面一个参数 就会成为当前线程的名称。如果不了解 可以先查看我的文章。
java 线程接口启动_Java 线程启动（实现Runnable接口）
weixin_32743475的博客
02-25 94
程序如下：class ThreadDemo1 implements Runnable{//实现Runnable接口private String name;private int time;public ThreadDemo1(String name,int time){this.name=name;this.time=time;}public void run() {//覆写run方法try {T...
Java 基础 第3阶段：高级应用-尚硅谷学习笔记（含面试题） 2023年
05-09
在Java的高级应用领域，开发者通常需要掌握一系列深入的技术和概念，这些内容涵盖了多线程、集合框架、网络编程、反射、I/O流、异常处理、设计模式等多个方面。在这个阶段的学习中，尚硅谷提供了2023年的学习笔记和...
4747-java自考复习资料串讲笔记完整版无水印.doc
09-30
Java 语言是面向对象的、跨平台...次要的重点章节是第二、四、七章，占30%，其余章节如第一、九、十章作为一般性了解，约占10%的考核分数。对于自考复习，理解和掌握这些关键知识点至关重要，有助于考生顺利通过考试。
Java语言程序设计学习笔记
05-22
20. **多线程**：创建线程的两种方式（继承Thread类和实现Runnable接口），线程同步和通信（synchronized、wait、notify等）。 21. **网络编程**：Socket和ServerSocket类的使用，实现客户端和服务器的通信。 22. ...
Java编程思想笔记(全)
最新发布
06-14
第二十二章介绍了Java中的图形用户界面开发。本章讲解了Swing和JavaFX两种GUI库的使用方法，包括如何创建窗口、布局管理器的使用、事件监听器的注册等内容。通过本章的学习，读者可以了解如何构建具有友好界面的应用...
毕向东_Java基础课堂笔记.pdf
04-21
综上所述，毕向东_Java基础课堂笔记涵盖了Java编程的基础知识和核心概念，从简单的编程基础到面向对象编程，再到具体的高级特性如多线程、网络编程等。对于初学者来说，这些内容都是学习Java的必经之路，也是构建...
Java多线程之Thread类、Runnable接口（一）
橘子上树丶的博客
04-26 219
1、阐述要用多线程，多线程为什么极其重要 2、阐述 Thread 类及底层原理 3、阐述 Runnable 接口及底层原理
杂记2：android：java线程，多重runnable套接
xxxxzzz123的博客
08-22 739
今天遇到了很奇怪的runnable写法，之前Thread的两种基础写法就不多说了。记一下今天遇到的写法： public class httpThread2 implements Runnable { private static httpThread2 sc; private Handler handler; public static synchronized httpThrea
Runnable 注解注入
张小凡
08-23 5121
一构造函数的形式传入注解即可 public class RunnableTask implements Runnable { private int projectId; private TransactionService transactionService; // 这个就是注解注入 RunnableTask() { } // 注解在别的...
java向线程中传递参数的方法
热门推荐
xt_chaoji的专栏
11-15 1万+
向线程中传递数据的三种方法： 一、通过构造函数传递参数 public class MyThread1 extends Thread {     private String name;     public MyThread1(String name)     {         this.name = name;     }     public void run()
java多线程runnable_java线程中的runnable接口
weixin_30229479的博客
02-12 417
我们在java中使用线程的时候有两种方式1.是利用Thread类的子类的实例2.利用runnable接口的实现类的实例在这两种方式中，使用Thread的子类去创建线程的优点是，我们可以在其子类中增加新的成员变量，是线程具有某种属性，也可以在子类中新增加方法，是线程具有某种功能。但是由于java中不支持多继承，如果我们想在Thread上扩展其他类的功能，这种方式就行不通了。为此就有了线程创建的另一种...
Java中Runnable与Callable的那些事
淡定_蜗牛的博客
01-30 392
1.概述 自Java早期以来，多线程一直是该语言的一个主要方面。Runnable是用于表示多线程任务的核心接口，Callable是在Java 1.5中添加的Runnable的改进版本。 在本文中，我们将探讨两种接口的差异和应用。 2.执行机制 两个接口都旨在表示可由多个线程执行的任务。Runnable的任务都可以使用运行线程类或ExecutorService的，而可调用只能用后者来运行。 3.返回...
多线程中 获取不到 @Autowired 和@Resource 注入的对象
haodiaoji9386的博客
03-11 434
多线程中 获取不到 @Autowired 和@Resource 注入的对象 老是提示空指针异常 可以使用工具类 手动获取改对象 工具类: package top.canye.sys.util; import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.context.Applic...
Spring 实现线程接口 Runnable 注解注入失败 @Resource annotation is not supported on static fields
zhi_heart的专栏
10-09 1万+
原因就是spring和多线程安全的问题，不让注入 解决方案有以下几种一.变量前缀加static,生成set方法并加上@Resource,记住把set方法 static 去掉,否则会抛出 @Resource annotation is not supported on static fieldsprivate static VerificDao verificDao; @Resource publi
java 线程 this_java线程中this,这个this可以用什么替换
weixin_31569663的博客
02-12 404
publicclassExample{publicstaticvoidmain(Stringargs[]){Bankbank=newBank();bank.setmoney(300);bank.会计.start();bank.出纳.start();}}classBankimplementsRunnable{privateintmo...public class Example{public sta...
Java多线程：实现Runnable接口创建线程
`Runnable`接口是Java多线程编程的基础，通过实现这个接口，程序员可以创建自己的线程逻辑，并利用`Thread`类提供的功能来管理线程的生命周期，实现并发执行和资源的共享与保护。理解并熟练掌握这些知识对于编写高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值