A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 厦门校区 黑马粉丝团   /  2018-8-18 20:52  /  5840 人查看  /  93 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

1.多线程的实现有几种方式?实现步骤分别是怎样的?
2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
4.sleep()方法和wait()方法的区别?
5.线程有几种状态?他们之间是如何转化的?

93 个回复

倒序浏览

yefan

1.多线程的实现有几种方式?实现步骤分别是怎样的?    有两种方式:
                1 . 子类继承thread类, 重写run方法,.
                 2. 实现runnable 接口重写run方法.
2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
    Runnable接口是对Thread总run方法的抽取,实现Runnable能降低类与类的耦合度,使用更加灵活
3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
     当多个线程同时读取一个共享数据时会发生不可控的数据异常,
     可以使用互斥锁, synchronized代码块 和 synchronized方法
4.sleep()方法和wait()方法的区别?
   sleep必须是有参  wait可以有参可以无参
    sleep在设定的时间段内不释放锁
     wait会马上释放锁
5.线程有几种状态?他们之间是如何转化的?

    1. 初始(NEW):新创建了一个线程对象,但还没有调用start()方法。
2. 运行(RUNNABLE):当调用start方式时如果抢到锁就运行
3. 阻塞(BLOCKED):如果没有抢到锁就等状态
4. 等待(WAITING):进入该状态的线程需要等待其他线程做出一些特定动作(通知或中断)。
5. 时等待(TIME_WAITING):该状态不同于WAITING,它可以在指定的时间后会自动唤醒。

6. 终止(TERMINATED):表示该线程已经执行完毕。

点评

发表于 2019-7-20 12:36
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
    2种。
    通过将类声明为Thread的子类。定义Thread的子类,重写run方法,方法体为线程要完成的任务。创建Thread的子类的对象也就是线程对象,通过线程对象调用star方法。
      通过定义Runnable接口实现类,重写run方法,方法体为线程要完成的任务。创建实现类对象,通过该对象为参数创建Thread对象,该对象是线程对象。在通过线程对象调用    start方法启动线程。
2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
   
继承Thread类线程对象与线程任务绑定。

    实现Runnable接口把线程对象与线程任务分离解耦。

     实现Runnable接口优势:避免了继承的局限性,且实现了多线程共享资源。

3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
   
线程安全问题:
多线程执行任务与单线程执行时结果不同。

   有3种方式解决线程安全问题。
   1、同步代码块
   2、同步方法
   3、实现Lock接口,调用lock()方法和unlock()方法
4.sleep()方法和wait()方法的区别?
  
sleep(参数)括号内为定时的时间毫秒值,时间到唤醒线程

   wait()为无限等待,需要被其他线程唤醒用notify()方法等

5.线程有几种状态?他们之间是如何转化的?
  6种状态
    新建。未启动
可执行。
阻塞。当一个对象获取锁对象,其他试图获取锁对象的线程进入阻塞状态
计时等待。Thread.sleepObject.wait方法,当超过设定时间,或被唤醒,终止等待,如获取了锁对象,则进入可执行状态,否在进入阻塞。
无限等待。一个线程进入Waiting状态,没有其他线程唤醒,无则处于等待状态。唤醒后如获取了锁对象,则进入可执行状态,否在进入阻塞。
    终止 run方法正常退出而死亡,或因没有捕获的异常终止了run方法而死亡。

点评

发表于 2019-7-20 12:37
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
三种
1,实现线程类接口,重写run方法,创建实现类对象,创建线程接口子类对象并且把实现类对象赋值其中,最后调用start
2.创建接口子类继承类,重写run方法,创建继承类对象,调用start方法
3.new一个接口子类在其中new线程接口并且重写run方法
2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
区别在于将重写和调用分开了,可操作性加强了
3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
多线程对一变量进行同时操作,使用锁,三种,同步代码块,同步方法,Lock锁
4.sleep()方法和wait()方法的区别?
wait是让线程进入永久睡眠状态,sleep是进入读秒停止状态
5.线程有几种状态?他们之间是如何转化的?
六种,开始-->运行--(如果使用sleep方法-->进入读秒暂停状态/--如果使用wait方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态)-->程序结束
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
三种
1,实现线程类接口,重写run方法,创建实现类对象,创建线程接口子类对象并且把实现类对象赋值其中,最后调用start
2.创建接口子类继承类,重写run方法,创建继承类对象,调用start方法
3.new一个接口子类在其中new线程接口并且重写run方法
2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
区别在于将重写和调用分开了,可操作性加强了
3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
多线程对一变量进行同时操作,使用锁,三种,同步代码块,同步方法,Lock锁
4.sleep()方法和wait()方法的区别?
wait是让线程进入永久睡眠状态,sleep是进入读秒停止状态
5.线程有几种状态?他们之间是如何转化的?
六种,开始-->运行--(如果使用sleep方法-->进入读秒暂停状态/--如果使用wait方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态)-->程序结束
回复 使用道具 举报
本帖最后由 张煜兴 于 2018-8-19 15:52 编辑

1.多线程的实现有几种方式?实现步骤分别是怎样的?
两种实现方式,
一、继承方法:
(1)先创建继承了Thread的类,重写run方法,
(2)创建此类的对象,
(3)通过对象调用start方法开启新线程执行run方法
二、实现类Runnable的Thread类方法
(1)定义Runnable接口的实现类,重写run方法,
(2)创建该实现类的对象,作为Thread的构造函数参数创建Thread对象,
(3)用Thread对象调用start方法开启新线程执行run方法


2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
(1)解决了继承Thread类单继承的问题,实现多实现
(2)降低了继承Thread类的run方法设置任务和start方法开启新线程这两者间的耦合度
(3)实现共享数据的前提
(4)线程池只能放入实现Runable或callable类线程,不能直接放入继承Thread的类。

3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
是因为JAVA是抢占式运行多线程的,当一个线程的执行任务还没结束时,就被其他线程抢走了,导致删除和更改操作的数据出现异常
有五种解决方法,一、同步代码块,二、同步方法,三、静态同步方法,四、lock、unlock方法,五、wait、notify方法

4.sleep()方法和wait()方法的区别?
sleep():计时等待,计时结束,继续执行代码
wait():无限等待,一直等到被notify解锁

5.线程有几种状态?他们之间是如何转化的?
6种状态,新建的线程,互相抢占资源,抢到资源的进入运行,没抢到的进入阻塞,被wait的进入无限等待,被sleep的进入计时等待,执行结束的被终止。


回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
三种
1,实现线程类接口,重写run方法,创建实现类对象,创建线程接口子类对象并且把实现类对象赋值其中,最后调用start
2.创建接口子类继承类,重写run方法,创建继承类对象,调用start方法
3.new一个接口子类在其中new线程接口并且重写run方法
2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
区别在于将重写和调用分开了,可操作性加强了
3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
多线程对一变量进行同时操作,使用锁,三种,同步代码块,同步方法,Lock锁
4.sleep()方法和wait()方法的区别?
wait是让线程进入永久睡眠状态,sleep是进入读秒停止状态
5.线程有几种状态?他们之间是如何转化的?
六种,开始-->运行--(如果使用sleep方法-->进入读秒暂停状态/--如果使用wait方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态)-->程序结束
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
三种
1,实现线程类接口,重写run方法,创建实现类对象,创建线程接口子类对象并且把实现类对象赋值其中,最后调用start
2.创建接口子类继承类,重写run方法,创建继承类对象,调用start方法
3.new一个接口子类在其中new线程接口并且重写run方法
2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
区别在于将重写和调用分开了,可操作性加强了
3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
多线程对一变量进行同时操作,使用锁,三种,同步代码块,同步方法,Lock锁
4.sleep()方法和wait()方法的区别?
wait是让线程进入永久睡眠状态,sleep是进入读秒停止状态
5.线程有几种状态?他们之间是如何转化的?
六种,开始-->运行--(如果使用sleep方法-->进入读秒暂停状态/--如果使用wait方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态)-->程序结束
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
三种
1,实现线程类接口,重写run方法,创建实现类对象,创建线程接口子类对象并且把实现类对象赋值其中,最后调用start
2.创建接口子类继承类,重写run方法,创建继承类对象,调用start方法
3.new一个接口子类在其中new线程接口并且重写run方法
2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
区别在于将重写和调用分开了,可操作性加强了
3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
多线程对一变量进行同时操作,使用锁,三种,同步代码块,同步方法,Lock锁
4.sleep()方法和wait()方法的区别?
wait是让线程进入永久睡眠状态,sleep是进入读秒停止状态
5.线程有几种状态?他们之间是如何转化的?
六种,开始-->运行--(如果使用sleep方法-->进入读秒暂停状态/--如果使用wait方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态)-->程序结束
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
三种
1,实现线程类接口,重写run方法,创建实现类对象,创建线程接口子类对象并且把实现类对象赋值其中,最后调用start
2.创建接口子类继承类,重写run方法,创建继承类对象,调用start方法
3.new一个接口子类在其中new线程接口并且重写run方法
2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
区别在于将重写和调用分开了,可操作性加强了
3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
多线程对一变量进行同时操作,使用锁,三种,同步代码块,同步方法,Lock锁
4.sleep()方法和wait()方法的区别?
wait是让线程进入永久睡眠状态,sleep是进入读秒停止状态
5.线程有几种状态?他们之间是如何转化的?
六种,开始-->运行--(如果使用sleep方法-->进入读秒暂停状态/--如果使用wait方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态)-->程序结束
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
三种
1,实现线程类接口,重写run方法,创建实现类对象,创建线程接口子类对象并且把实现类对象赋值其中,最后调用start
2.创建接口子类继承类,重写run方法,创建继承类对象,调用start方法
3.new一个接口子类在其中new线程接口并且重写run方法
2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
区别在于将重写和调用分开了,可操作性加强了
3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
多线程对一变量进行同时操作,使用锁,三种,同步代码块,同步方法,Lock锁
4.sleep()方法和wait()方法的区别?
wait是让线程进入永久睡眠状态,sleep是进入读秒停止状态
5.线程有几种状态?他们之间是如何转化的?
六种,开始-->运行--(如果使用sleep方法-->进入读秒暂停状态/--如果使用wait方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态)-->程序结束
回复 使用道具 举报

1.多线程的实现有几种方式?实现步骤分别是怎样的?
两种。
Thread:创建Thread的子类,并重写run方法,创建子类对象并调用start方法。
Runnable:创建Runnable的实现类,并重写run方法,创建实现类的实例(r),创建线程对象(r)并调用start方法。

2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
Runnable的实现类对象只是线程目标,并非线程对象。
1.Thread单继承的局限性
2.Runnable方便共享。
3.程序的健壮性及解耦。
4.线程池可以放Runnable的实现类,不能存放Thread子类。

3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
多线程执行同一任务时出现与单线程不一样的结果。
通过线程同步。
同步代码块/同步方法/锁机制

4.sleep()方法和wait()方法的区别?
sleep()是短暂停止,过了既定时间后且获得锁对象即可变成运行状态,不会释放锁对象。
wait方法会释放锁对象,且她必须有人用notify方法唤醒才有可能进入运行状态。

5.线程有几种状态?他们之间是如何转化的?
6种。NEW新建/RUNNABLE可运行/WAIT无限等待/即使等待/锁阻塞/终止
如何转化请过来,我画图比较方便。
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
三种
1,实现线程类接口,重写run方法,创建实现类对象,创建线程接口子类对象并且把实现类对象赋值其中,最后调用start
2.创建接口子类继承类,重写run方法,创建继承类对象,调用start方法
3.new一个接口子类在其中new线程接口并且重写run方法
2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
区别在于将重写和调用分开了,可操作性加强了
3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
多线程对一变量进行同时操作,使用锁,三种,同步代码块,同步方法,Lock锁
4.sleep()方法和wait()方法的区别?
wait是让线程进入永久睡眠状态,sleep是进入读秒停止状态
5.线程有几种状态?他们之间是如何转化的?
六种,开始-->运行--(如果使用sleep方法-->进入读秒暂停状态/--如果使用wait方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态)-->程序结束
回复 使用道具 举报

1.多线程的实现有几种方式?实现步骤分别是怎样的?
答:有两种。使用继承类的方式创建多线程,1)子类继承Thread 。2) 重写run方法。
3) 创建子类对象。4) 用子类对象调用start方法。使用实现接口的方式创建多线程,
1) 实现类 implements Runnable 。2) 重写run方法。3) 创建实现类对象(线程任务对象)
4) 创建线程对象  new Thread()。 5) 传递线程任务对象 new Thread()。6) 调用线程对象
并调用start方法。

2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
答: 继承Thread类,线程任务和线程对象绑定在一起。实现Runnable接口实现线程任务和
线程对象分离。
优势:1) 避免了,Java的单继承的局限性
          2) 实现了代码的解耦,可以将线程任务与线程对象进行分离,可以让多个线程对象执行同一个线程任务
          3) 让我们做一些共享数据的操作的前提条件

3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
答:共享一个线程任务的时候,涉及到多个线程操作(修改、写的操作)一个全局的或者静态的资源数据的时候
会发生,数据不符合预期,数据错误。解决线程安全问题,有3种方式.同步代码块,同步方法,实现look接口。

4.sleep()方法和wait()方法的区别?
答:sleep()方法不会释放锁,只是延迟运行时间。wait()方法会释放锁。
5.线程有几种状态?他们之间是如何转化的?
答:6个。NEW(新建)、RUNNABLE(运行)、BOLCKED(阻塞)、TIMED-WAITING(计时等待)、
WANTING(无限等待)、TERMINATE(终止)。new到run,有锁对象的直接执行。没有锁对象的就
无限等待,当其他线程通过notify方法调用没有无限等待的对象时。若有锁对象则直接执行,若没有则
到锁阻塞,锁阻塞的对象若争取到锁就执行。有sleep的在获得锁对象后调用wait()方法到计时等待,
wait时间到判断有没有取到锁。若有则执行,若无则到锁阻塞。

(黄嘉欣)
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
两种方式:
继承Thread类:创建一个类继承与Thread接口,重写run方法
实现runnable接口:创建一个类实现runnable接口,重写run方法


2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
区别在于继承Thread类只能是单继承,而实现接口可以多实现
优势:
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程,不能直接放入继承Thread的类。




3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
共享一个线程任务的时候,涉及到多个线程操作(修改、写的操作)一个全局的或者静态的资源数据的时候会发生,数据不符合预期,数据错误
解决方法:
将可能出现线程安全问题的代码用同步代码块包裹起来,一共有三种方法:同步代码块,同步方法,锁机制 (lock)



4.sleep()方法和wait()方法的区别?
sleep():使线程睡眠指定的时间,暂停任务,此时线程还持有锁
wait():使线程进入无限期睡眠,等待其他线程唤醒,此时线程释放锁,没有持有锁,被唤醒后,如果抢到锁进入runnable 状态,如果没前抢到则进入blocked状态



5.线程有几种状态?他们之间是如何转化的?
六种状态:
New新建状态
Blocked阻塞状态
Runnable运行状态
Waiting无限期等待状态
Timed waiting 计时等待状态
Teminated(终止状态)

线程刚被创建处于new状态,调用start()方法后进入运行状态,运行结束后进入终止状态.
若线程调用wait()方法,则进入无限期等待状态,等待 其他线程唤醒,唤醒后,如果抢到锁进入运行状态,如果没抢到则进入阻塞状态,等待下一次抢锁.


回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?Thread:1、创建Thread的子类;2、重写run()方法;3、创建子类对象;4、调用start()方法;
runnable:1、创建runnable的实现类;2、重run()方法;3、创建实现类对象,并把此对象作为Thread的target来创建Thread对象;4、调用start();
2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
1、避免了单继承的局限性;
2、增加了程序的拓展性,降低程序的耦合性;
3、共享数据的前提;
3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
当多个线程执行同一个线程任务时,每次运行的结果不能和单线程的结果一样,其他变量的值也和预想的不一样;
解决线程安全有三种方式:1、同步代码块;2、同步方法;3、Lock锁;
4.sleep()方法和wait()方法的区别?
sleep()可以设置睡眠时间,不能主动释放锁;
wait()除非被唤醒否则无限等待,可以主动释放锁;
5.线程有几种状态?他们之间是如何转化的?
6种:new,runnable,blocked,waiting,time-waiting,teminated;
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
四种。目前学了两种,分别为:

继承Thread类,重写run方法,创建子类对象,实例调用start(),开启新线程;
实现Runnable接口,重写run方法,实现Runnable接口的实现类的实例对象作为Thread构造函数的target,Threa的实例实例对象调用Start(),开启新线程。

2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
区别:继承Thread类是多个线程分别完成自己的任务,实现Runnable是多个线程共同完成一个任务
实现Runnable接口的优势:
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和数据独立。
4. 线程池只能放入实现Runable或callable类线程,不能直接放入继承Thread的类。


3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
多个线程共享同一资源,同时对其进行改写、设置等操作。造成了异常数据,例如课程中的例子卖票造成的,一张票重复卖出,或者卖了第0、-1张票。


4.sleep()方法和wait()方法的区别?
sleep():相当于运行了一个方法,而方法体的运行时间为设置的参数,不会释放锁,时限到后,继续执行下列代码;
wait():是位于同步代码块里面的,调用该方法,就释放锁,处于计时等待或者无限等待,时限到了或者被其他线程notify()唤醒,这是就加入到对锁的争抢当中,只有当抢到锁,才会进行运行状态,否则则为锁阻塞状态。


5.线程有几种状态?他们之间是如何转化的?
6种。
1.NEW(新建) 线程刚被创建,但是并未启动。
2.Runnable(可运行)
线程可以在java虚拟机中运行的状态,可能正在运行自己代码,也可能没有,这取决于操作系统处理器。
3.Blocked(锁阻塞)
当一个线程试图获取一个对象锁,而该对象锁被其他的线程持有,则该线程进入Blocked状态;当该线程持有锁时,该线程将变成Runnable状态。
4.Waiting(无限等待)
一个线程在等待另一个线程执行一个(唤醒)动作时,该线程进入Waiting状态。进入这个状态后是不能自动唤醒的,必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
5.Timed Waiting(计时等待)
同waiting状态,有几个方法有超时参数,调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。
6.Teminated(被终止)
因为run方法正常退出而死亡,或者因为没有捕获的异常终止了run方法而死亡。


回复 使用道具 举报
1.Runnable接口,Thread类
2.Thread只能继承一个类实现了Runnable的类,还可以继承其他接口 优势在于1.避免java单继承性2.实现代码解耦3.共享数据前提.4.代码和线程独立
3.多线程运行的结果和单线程运行的结果不一样,不符合我们的预期.使用线程同步来解决.同步代码块,同步方法,静态同步方法
4.sleep()程序暂停执行指定的时间,让出cpu该其他线程,但是他的监控状态依然保持者,当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中,线程不会释放对象锁.
   wait线程会放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象调用notify()方法后本线程才进入对象锁定池准备
5.创建:线程刚被创建,但是并未启动。还没调用start方法.
可运行:线程可以在java虚拟机中运行的状态,可能正在运行自己代码,也可能没有,这取决于操 作系统处理器,
锁阻塞,:当一个线程试图获取一个对象锁,而该对象锁被其他的线程持有,则该线程进入Blocked状 态;当该线程持有锁时,该线程将变成Runnable状态。
无限等待:一个线程在等待另一个线程执行一个(唤醒)动作时,该线程进入Waiting状态。进入这个 状态后是不能自动唤醒的,必须等待另一个线程调用notify或者notifyAll方法才能够唤醒
计时等待:同waiting状态,有几个方法有超时参数,调用他们将进入Timed Waiting状态。这一状态 将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、 Object.wait。
被终止:因为run方法正常退出而死亡,或者因为没有捕获的异常终止了run方法而死亡。
回复 使用道具 举报
1.Runnable接口,Thread类
2.Thread只能继承一个类实现了Runnable的类,还可以继承其他接口 优势在于1.避免java单继承性2.实现代码解耦3.共享数据前提.4.代码和线程独立
3.多线程运行的结果和单线程运行的结果不一样,不符合我们的预期.使用线程同步来解决.同步代码块,同步方法,静态同步方法
4.sleep()程序暂停执行指定的时间,让出cpu该其他线程,但是他的监控状态依然保持者,当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中,线程不会释放对象锁.wait线程会放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象调用notify()方法后本线程才进入对象锁定池准备
5.创建:线程刚被创建,但是并未启动。还没调用start方法.
可运行:线程可以在java虚拟机中运行的状态,可能正在运行自己代码,也可能没有,这取决于操 作系统处理器,
锁阻塞,:当一个线程试图获取一个对象锁,而该对象锁被其他的线程持有,则该线程进入Blocked状 态;当该线程持有锁时,该线程将变成Runnable状态。
无限等待:一个线程在等待另一个线程执行一个(唤醒)动作时,该线程进入Waiting状态。进入这个 状态后是不能自动唤醒的,必须等待另一个线程调用notify或者notifyAll方法才能够唤醒
计时等待:同waiting状态,有几个方法有超时参数,调用他们将进入Timed Waiting状态。这一状态 将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、 Object.wait。
被终止:因为run方法正常退出而死亡,或者因为没有捕获的异常终止了run方法而死亡。
回复 使用道具 举报
1.Runnable接口,Thread类
2.Thread只能继承一个类实现了Runnable的类,还可以继承其他接口 优势在于1.避免java单继承性2.实现代码解耦3.共享数据前提.4.代码和线程独立
3.多线程运行的结果和单线程运行的结果不一样,不符合我们的预期.使用线程同步来解决.同步代码块,同步方法,静态同步方法
4.sleep()程序暂停执行指定的时间,让出cpu该其他线程,但是他的监控状态依然保持者,当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中,线程不会释放对象锁.
   wait线程会放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象调用notify()方法后本线程才进入对象锁定池准备
5.创建:线程刚被创建,但是并未启动。还没调用start方法.
可运行:线程可以在java虚拟机中运行的状态,可能正在运行自己代码,也可能没有,这取决于操 作系统处理器,
锁阻塞,:当一个线程试图获取一个对象锁,而该对象锁被其他的线程持有,则该线程进入Blocked状 态;当该线程持有锁时,该线程将变成Runnable状态。
无限等待:一个线程在等待另一个线程执行一个(唤醒)动作时,该线程进入Waiting状态。进入这个 状态后是不能自动唤醒的,必须等待另一个线程调用notify或者 notifyAll 方法才能够唤醒
计时等待:同waiting状态,有几个方法有超时参数,调用他们将进入Timed Waiting状态。这一状态 将一直保持到超时期满或者接收到唤醒通知。被终止:因为run方法正常退出而死亡,或者因为没有捕获的异常终止了 run方法而死亡。
回复 使用道具 举报
1234下一页
您需要登录后才可以回帖 登录 | 加入黑马