Day15 线程的3种开启方式,5种状态,控制线程安全

最新推荐文章于 2022-04-08 22:35:37 发布
最新推荐文章于 2022-04-08 22:35:37 发布
阅读量214 收藏 3
点赞数
分类专栏： JAVASE笔记 文章标签： 线程的开启方式 线程的状态 控制线程安全 多线程 同步锁synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44695396/article/details/90144933
版权

一 线程的开启方式

多线程:多任务同时执行就是多线程,如果没有多任务任务,就不需要使用多线程
线程和进程之间的区别:
进程:资源分配的最小单位
线程:cpu调度的最小单位
一个进程可以包含1~n个线程

1.继承Thread类,重写run()方法

继承Thread类,重写run()方法
 创建子类对象,调用start()方法,开启多线程

public class ThreadDemo01 extends Thread{
    /*
     * 多线程的入口
     * 定义代码|调用其他方法都可以
     */
    @Override
    public void run() {
        for(int i=1;i<=100;i++){
            System.out.println("徐文一边哄女朋友....");
        }
    }
    
    public static void main(String[] args) {
        ThreadDemo01 th=new ThreadDemo01();
        //void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
          th.start();  //开启线程
//        th.run();   //调用的是普通run()方法,并不是多线程
        
        for(int i=1;i<=100;i++){
            System.out.println("徐文一边敲代码....");
        }
        
       // th.start();//循环走完了才开启线程,达不到多线程的效果
    }
}

2.实现Runnable接口,重写run()方法(用的最多)

实现Runnable接口,重写run()方法 **
开启线程: Thread类做代理,调用Thread类中的start方法开启线程
  
    优点:
       避免了单继承的局限性
       实现资源共享

public class ThreadDemo02 implements Runnable{
    /*
     * 多线程的入口
     * 定义代码|调用其他方法都可以
     */
    @Override
    public void run() {
        for(int i=1;i<=100;i++){
            System.out.println("徐文一边哄女朋友....");
        }
    }
    
    public static void main(String[] args) {
        ThreadDemo02 th=new ThreadDemo02();
        Thread t=new Thread(th);//因start()方法是Thread类里面的,只有Thread或继承它的类才可以调用start()方法,所以需要创建Thread对象
        //void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
        t.start();  //开启线程
        
        for(int i=1;i<=100;i++){
            System.out.println("徐文一边敲代码....");
        }
    }
}

3.实现Callable接口,重写call()方法(了解)

 优点:可以有返回值,可以抛出异常
 缺点:使用复杂
  
public class Match06 implements Callable{
    String winner=null; //存储胜利者的名字
    
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //创建线程
         ExecutorService ser=Executors.newFixedThreadPool(2);
         //获取值
         Match06 match=new Match06();
         Future<Integer> result1 =ser.submit(match) ;
         Future<Integer> result2 =ser.submit(match) ;
         int num1 =result1.get();
         int num2 =result2.get();
         System.out.println("乌龟跑了-->"+num1+"步");
         System.out.println("小兔子跑了-->"+num2+"步");
         //停止服务
         ser.shutdownNow();

    }

    private boolean gameOver(int i) {
        if(winner!=null){
            return true;
        }else{
            if(i==100){
                winner=Thread.currentThread().getName();
                return true;
            }
        }
        return false;
    }

    @Override
    public Object call() throws Exception {
        for(int i=1;i<=100;i++){
            if("rabbit".equals(Thread.currentThread().getName())&& i%10==0){
                try {
                    Thread.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"在跑第"+i+"步");
            boolean flag=gameOver(i);
            if(flag){
                return i;
            }
        }
        return null;
    }

}

二 线程的5种状态

/*
 * 线程的状态:
 *     新生状态:new线程对象的时候,这个线程处于新生状态
 *     就绪状态:调用start()方法,线程进入就绪状态,进入到就绪队列,进入就绪状态代表线程有能力执行,但是要等到cpu调用,分配时间片才能执行
 *     运行状态:当前cpu调度,分配时间片给就绪状态的线程,当前线程执行
 *     阻塞状态:sleep...
 *     终止状态:线程结束
 *
 * 1.如果线程一旦进入到阻塞状态不会直接进入运行状态,阻塞状态解除要进入到就绪状态
 * 2.线程一旦结束,无法恢复,如果重新开启,也是一个新的线程
 *
 * 如何控制线程的终止:
 *  1.调用stop(),destory(),已过时,不推荐
 *  2.线程正常执行结束
 *  3.添加标识控制
 *  
 * 进入线程就绪状态的几种情况:
 *     1.start()方法
 *     2.yield 礼让线程
 *     3.线程之前切换
 *     4.解除阻塞状态,线程进入到就绪状态
 *
 * 进入线程阻塞状态的几种情况:
 *  1.sleep方法
 *  2.join方法
 *  3.wait方法
 *  4.IO操作
 */

    sleep和wait方法的区别

1.这两个方法来自不同的类分别是Thread和Object

2.最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法

3.(使用范围)wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用

4.sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

5.sleep()方法是一个静态方法，也就是说他只对当前对象有效.wait属于Object的成员方法，一旦一个对象调用了wait方法，必须要采用notify()和notifyAll()方法唤醒该进程
      sleep延迟
1.放大问题的可能性
2.模拟网络延迟

yield
yield 高风亮节 礼让线程
如果当前线程调用yield方法,会直接进入到就绪状态
 

 join 插队

/*
 * 查看线程的状态:
 *     Thread.State      getState()  返回该线程的状态。
 *
 * 线程优先级:
 *     void setPriority(int newPriority) 更改线程的优先级。
 *  int getPriority() 返回线程的优先级
 *  1~10表示  1是最小   10是最大  默认是5
 *  MIN_PRIORITY 最小
 *  NORM_PRIORITY 默认
 *  MAX_PRIORITY 最大
 *  
 */

三 控制线程安全

/*
 * 多个线程同时操作同一份资源的时候,可能会发生线程不安全问题
 * 控制线程安全:加锁   synchronized 同步
 *     (1) 同步方法: 在方法上面加锁
 *         同步静态方法
 *         同步成员方法
 *     (2) 同步块: synchronized(){}
 *         锁this,锁资源,                       (锁类会变成死锁)

       (3) Lock锁

 *  
 *  锁的必须是不变的内容
 *  锁的范围太大,效率低,锁的范围太小,容易锁不住
 *  
 *  
 *  单例:懒汉式是线程不安全的
 *      锁静态方法
 *  
 *  double check 双重检查,效率更高
 *  
 *  锁类锁静态方法都是锁类,在static方法中不能使用this,所以不能锁对象
 */

1.锁方法

/*
 * 锁方法 控制线程安全
 */
public class Web12306_02 implements Runnable{
    //100张票资源
    int tickets=100;
    /*
     * 买票
     */
    @Override
    public void run() {
        while(true){
            //停止条件
            //A B C
            if(!test()){
                break;
            }
        }
    }
    //锁方法
    public synchronized boolean test(){
        if(tickets<=0){
            return false;
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"买了第"+tickets--);
        return true;
    }
    
    

    public static void main(String[] args) {
        Web12306_02 web=new Web12306_02();
        //开启线程
        new Thread(web,"小小赵").start();
        new Thread(web,"小小强").start();
        new Thread(web,"小小明").start();
    }
}

2.锁this就是锁对象

/*
 * 锁 块  控制线程安全
 *  锁this就是锁对象,锁对象会锁住这个对象中的所有成员(资源),如果只想锁住其中的某个资源,可以只锁这个资源
 */
public class Web12306_03 implements Runnable{
    //100张票资源
    int tickets=100;
    /*
     * 买票
     */
    @Override
    public void run() {
        while(true){
            //停止条件
            synchronized (this) {  //锁资源对象
                if(tickets<=0){
                    break;
                }
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"买了第"+tickets--);
            }
        }
    }

    public static void main(String[] args) {
        Web12306_03 web=new Web12306_03();
        //开启线程
        new Thread(web,"小小赵").start();
        new Thread(web,"小小强").start();
        new Thread(web,"小小明").start();
        
    }
}

3.锁资源

/*
 * 锁 块  控制线程安全
 *  锁资源 一般就是指成员属性,锁一定要锁不变的内容,对象的地址永远不变,自定义的引用数据类型肯定能锁住
 */
public class Web12306_04 implements Runnable{
    //100张票资源
    Ticket tickets=new Ticket();//如果不创建对象,值会改变,锁不住
    /*
     * 买票
     */
    @Override
    public void run() {
        while(true){
            //停止条件
            synchronized (tickets) {  //锁资源的地址,是对象肯定能锁住
                if(tickets.num<=0){
                    break;
                }
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"买了第"+tickets.num--);
            }
        }
    }

    public static void main(String[] args) {
        Web12306_04 web=new Web12306_04();
        //开启线程
        new Thread(web,"小小赵").start();
        new Thread(web,"小小强").start();
        new Thread(web,"小小明").start();
        
    }
}

class Ticket{
    int num=100;
}

4.锁类的class对象

/*
 * 锁 块  控制线程安全
 *  锁类的class对象,锁类,锁不变的东西
 *      锁类,这个类的所有对象都被锁住了
 *      锁this,值只锁住当前对象
 */
public class Web12306_05 implements Runnable{
    //100张票资源
    int tickets=100;
    /*
     * 买票
     */
    @Override
    public void run() {
        while(true){
            //停止条件
            synchronized (Web12306_05.class) {  //锁资源对象
                if(tickets<=0){
                    break;
                }
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"买了第"+tickets--);
            }
        }
    }

    public static void main(String[] args) {
        Web12306_05 web=new Web12306_05();
        //开启线程
        new Thread(web,"小小赵").start();
        new Thread(web,"小小强").start();
        new Thread(web,"小小明").start();
        
    }
}

四   java中的锁有哪些

lock比synchronized比较如下：

1) 支持公平锁，某些场景下需要获得锁的时间与申请锁的时间相一致，但是synchronized做不到
2) 支持中断处理，就是说那些持有锁的线程一直不释放，正在等待的线程可以放弃等待。如果不支持中断处理，那么线程可能一直无限制的等待下去，就算那些正在占用资源的线程死锁了，正在等待的那些资源还是会继续等待，但是ReentrantLock可以选择放弃等待
3) condition和lock配合使用，以获得最大的性能
JAVA中锁使用的几点建议：

1.如果没有特殊的需求，建议使用synchronized，因为操作简单，便捷，不需要额外进行锁的释放。鉴于JDK1.8中的ConcurrentHashMap也使用了CAS+synchronized的方式替换了老版本中使用分段锁（ReentrantLock）的方式，可以得知，JVM中对synchronized的性能做了比较好的优化。
2.如果代码中有特殊的需求，建议使用Lock。例如并发量比较高，且有些操作比较耗时，则可以使用支持中断的所获取方式；如果对于锁的获取，讲究先来后到的顺序则可以使用公平锁；另外对于多个变量的锁保护可以通过lock中提供的condition对象来和lock配合使用，获取最大的性能。

何以所谓
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程安全的几种方法
chenlizcj的博客
08-03 6269
通常情况下，一个进程中比较耗时的操作有文件上传下载，长循环，网络资源的获取，这个时候往往会采用多线程的方式来处理。 当进程中有多个并发线程在执行，并且需要处理一个数据代码块是，往往需要考虑线程安全问题，如果线程不安全的话，可能造成数据不一致的问题。 第一种实现线程安全的方式：同步代码块，即用synchronized关键字 第二种方法：同步方法，也是用synchronized关键字，只是这个关键字用在方法上了，把线程共享的数据块抽象成方法，在方法上加了同步锁。 第三种方法：使用Lock锁机制，对线程不
Java多线程（一）：基础概念及三种实现方式
iDark 的博客空间
08-28 163
多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。  一.线程的生命周期及五种基本状态 Java线程具有五中基本状态 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread(); 就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是...
线程控制（线程同步 & 线程安全）
YLH_yanlinghui的博客
11-12 424
一、线程同步        当多个控制线程共享相同的内存时，需要确保每个线程看到一致的数据。如果当某个线程可以去修改变量，而其他线程也可以去读取或者修改这个变量的时候，就需要对这些线程进行同步控制，以确保它们在访问变量的存储内容时不会访问到无效的数值。        同步：多进程或者多线程访问临界资源时，必须进行同步控制。多进程或者多线程的执行并不是完全绝对的并行运行，有可能主线程需要等待函数
线程安全并发处理原理分析和控制
lnn112233的博客
09-30 463
jvm主内存与工作内存 主内存主要包括本地方法区和堆。每个线程都有一个工作内存，工作内存中主要包括两个部分，一个是属于该线程私有的栈和对主存部分变量拷贝的寄存器(包括程序计数器PC和cup工作的高速缓存区)。   1.所有的变量都存储在主内存中(虚拟机内存的一部分)，对于所有线程都是共享的。 2.每条线程都有自己的工作内存，工作内存中保存的是主存中某些变量的拷贝，线程对变量的所有操作都必须在...
线程的启动方式和如何安全的中断线程
彼岸舞的博客
09-14 118
线程的基础概念应该都有了解了吧 认识Java里的线程 java天生就是多线程的 新启动线程的三种方式 package org.dance.day1; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTa...
线程的定义，启动方法和终止方法
evilmoon8256的博客
07-06 223
线程知识点总结—定义，启动和终止 1.线程与进程 线程是CPU调度的最小单位 进程是CPU内存分配的最小单位 一个进程中的所有线程共享一个内存空间 CPU使用抢占式调度，根据线程优先级来决定谁占有线程 每个线程都拥有自己的栈空间，但公用一个堆内存 2.线程启动 两种启动方式 static class MyThread extends Thread{ //复写run方法,在run方法中进行线程功能实现 @Override void run(){ .... } } static class MyRun
day33线程安全代码块设计思路_线程代码安全块_源码
10-04
在编程领域，线程安全是多线程编程中的一个关键概念，确保多个线程同时访问共享资源时不会引发数据不一致或错误状态。本篇文章将深入探讨“线程安全代码块”及其相关知识点，主要围绕Java语言中的`synchronized`...
DAY 15线程的基本语法.md
08-09
任务管理器可以有多个进程，每个进程运行的都是可执行程序，一个可执行程序就是一个软件，可执行程序的本质就是在计算机当中运行的一块代码
Day 22多线程、线程通信、线程池和Lambda表达式
12-22
多线程是程序设计中并行处理的一种方式。在Java中，可以通过继承`Thread`类或实现`Runnable`接口来创建线程。`WAITING`状态是线程的一种状态，当调用`wait()`方法时，线程会释放持有的锁资源并进入等待状态，等待...
多线程-day02.docx
12-12
在“多线程-day02”的学习资源中，我们深入探讨了Java内存模型以及多线程的特性与控制机制。 **Java内存模型** Java内存模型，也称为JVM内存模型，是Java程序员理解和掌握的基础知识，特别是在进行并发编程时。它...
实现多线程安全的3种方式
热门推荐
jinggod的博客
10-18 3万+
1、先来了解一下：为什么多线程并发是不安全的？  在操作系统中，线程是不拥有资源的，进程是拥有资源的。而线程是由进程创建的，一个进程可以创建多个线程，这些线程共享着进程中的资源。所以，当线程一起并发运行时，同时对一个数据进行修改，就可能会造成数据的不一致性，看下面的例子： 假设一个简单的int字段被定义和初始化： int counter = 0; 该counter字段在两个线程A和B
四种解决线程安全的方式：
weixin_40701758的博客
04-08 2953
线程安全的解决方式
线程开启的三种方式（一个类两个接口）
qq_39380737的博客
07-19 1337
第1种方式：继承Thread类（重写run方法） 实现部分： public class MyThread extends Thread{ //定义指定线程名称的构造方法 public MyThread(String name) { //调用父类的String参数的构造方法，指定线程的名称 super(name); } publi...
如何保证线程安全
wh柒八九的博客
10-12 736
本文来说下如何保证线程安全 文章目录线程安全等级 线程安全等级 之前的博客中已有所提及“线程安全”问题，一般我们常说某某类是线程安全的，某某是非线程安全的。其实线程安全并不是一个“非黑即白”单项选择题。 按照“线程安全”的安全程度由强到弱来排序，我们可以将java语言中各种操作共享的数据分为以下5类：不可变、绝对线程安全、相对线程安全、线程兼容和线程对立。 ...
如何实现线程安全?
zjcyou的专栏
03-02 361
四种方式    sychronized关键字    1. sychronized method(){}    2. sychronized (objectReference) {/*block*/}    3. static synchronized method(){}    4. sychronized(classname.class) 其中1和2是代表锁当前对象，即一个对象就一个锁，3和4...
java线程安全总结
web开发
02-10 390
原文： http://www.iteye.com/topic/806990 http://www.iteye.com/topic/808550 最近想将java基础的一些东西都整理整理，写下来，这是对知识的总结，也是一种乐趣。已经拟好了提纲，大概分为这几个主题： java线程安全，java垃圾收集，java并发包详细介绍，java profile和jvm性能调优 。慢慢写吧。本人j...
编写高效的线程安全类
wxyxl的专栏
05-04 857
在语言级支持锁定对象和线程间发信使编写线程安全类变得简单。本文使用简单的编程示例来说明开发高效的线程安全类是多么有效而直观。Java 编程语言为编写多线程应用程序提供强大的语言支持。但是，编写有用的、没有错误的多线程程序仍然比较困难。本文试图概述几种方法，程序员可用这几种方法来创建高效的线程安全类。并发性 只有当要解决的问题需要一定程度的并发性时，程序员才会从多线程应用程序中受益。例如

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值