java学习之- 线程运行状态
标签（空格分隔）： 线程运行状态
线程的运行状态：
如下是是我编写的一个图，大家可以作为参考：
1.new一个thread子类也是创建了一个线程；
2.创建完毕之后start（）-----运行，
3.然后从运行-------sleep（time）----冻结----sleep(time)时间到了，恢复到运行；
4.还有一种，是线程运行的时候------wait时间------到冻结状态-------然后notify（）唤醒-----然后恢复到运行状态；
5.消亡：线程运行中/冻结：stop()/run方法结束---------消亡；
6.临时状态：当前状态等待CPU的执行权，具备运行资格没有执行权，
7.冻结：放弃了执行资格；
8.冻结状态-----恢复---临时状态/运行状态；
获取线程的对象和名称：
创建了对象之后，都要匹配一个名称，线程的名称都要定义在线程的事物里面：
class Demo extends Thread{
private String name;
Demo(String name){
this.name=name;
}
public void run(){//将运行的代码放在run方法中
for(int x=0;x<60;x++) {
System.out.println(this.getName()+"demo run-----"+x);
}
}
}
class ThreadDemo{
public static void main(String[] args){
Demo d1= new Demo("one");//创建好一个线程
Demo d2= new Demo("two");
d1.start();
d2.start();
for(int x=0;x<60;x++){
System.out.println("helloworld!----"+x);
}
}
}
- 原来线程都有自己默认的名称，Thread-编号，该编号从零开始；
2.上述的名称是不是不太好看，这里可以使用set方法来定义名称；
获取当前线程的名称：
- static Thread currentThread():获取当前线程的对象；
getName():获取线程名称；
设置线程名称：setName或者构造方法；
练习：
- 需求是一个简单的卖票程序，多个窗口卖票，1号窗口在卖的时候，2号也在卖；多个窗口同时卖票，
观察如下的程序：
class Ticket extends Thread{
private int tick=100;
public void run(){
while (true){
if(tick>0) {
System.out.println(Thread.currentThread().getName()+"sale:" + tick--);
}
}
}
}
class TickDemo{
public static void main(String[] args){
Ticket t1=new Ticket();
Ticket t2=new Ticket();
Ticket t3=new Ticket();
Ticket t4=new Ticket();
t1.start();
t2.start();
t3.start();
t4.start();
}
}
执行结果：
发现100个票，卖出去了400张票；每个对象里面包含了100张票；
如何实现：100张票4个窗口正常售卖呢？，我们可以通过static定义变量来实现，如下
class Ticket extends Thread{
private static int tick=100;
public void run(){
while (true){
if(tick>0) {
System.out.println(Thread.currentThread().getName()+"sale:" + tick--);
}
}
}
}
class TickDemo{
public static void main(String[] args){
Ticket t1=new Ticket();
Ticket t2=new Ticket();
Ticket t3=new Ticket();
Ticket t4=new Ticket();
t1.start();
t2.start();
t3.start();
t4.start();
}
}
执行通过；
- 但是一般我们不使用静态，因为静态的生命周期比较长；
- 我们使用Thread创建线程不能实现了；
runable接口：
- Runable接口应该由那些打算通过某一线程执行实例的类来实现，类必须顶一个称为run的无参数方法，设计该接口的目的就是提供一个公共协议，例如，Thread类实现了Runable，激活的意思是某个线程已经启动并且尚未停止；
class Ticket implements Runnable{
private static int tick=100;
public void run(){
while (true){
if(tick>0) {
System.out.println(Thread.currentThread().getName()+"sale:" + tick--);
}
}
}
}
class TickDemo{
public static void main(String[] args){
// Ticket t1=new Ticket();
// Ticket t2=new Ticket();
// Ticket t3=new Ticket();
// Ticket t4=new Ticket();
// t1.start();
// t2.start();
// t3.start();
// t4.start();
Ticket t=new Ticket();
Thread t1=new Thread();
Thread t2=new Thread();
Thread t3=new Thread();
Thread t4=new Thread();
t1.start();
t2.start();
t3.start();
t4.start();
}
}
上述代码：能否实现呢？
分析：t1调用运行的run()是Thread里面的run,在这次代码里面未重写；
package com.wangaling;
class Ticket implements Runnable{
private static int tick=100;
public void run(){
while (true){
if(tick>0) {
System.out.println(Thread.currentThread().getName()+"sale:" + tick--);
}
}
}
}
class TickDemo{
public static void main(String[] args){
// Ticket t1=new Ticket();
// Ticket t2=new Ticket();
// Ticket t3=new Ticket();
// Ticket t4=new Ticket();
// t1.start();
// t2.start();
// t3.start();
// t4.start();
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();
}
}
执行结果：
上述代码可以正常实现售票的功能；
创建线程的第二种方式，实现runnable接口
步骤1：
1。定义类实现Runable接口；
2.覆盖Runable接口中的run方法：将线程要运行的代码存在在run方法中
3.通过Thread类建立线程对象
4.将Runable接口的子类对象作为实际参数传递给Thread类的构造函数：为什么要将Runable接口的子类的对象传递给Thread的构造函数，因为，自定义的run方法所属的对象是Runable接口的子类对象，所以要让线程去指定指定对象的run方法，就必须明确该run方法所属的对象；
5.调用Thread类的start方法开启线程，并调用Runable接口子类的run方法；
实现方式和继承方式有很么区别？
- 1.实现方式好处：避免了单继承的局限性，在定义线程的时候建议是用实现方式，可以避免单继承的实现性；
两种方式区别：
- 继承Thread：线程代码存放在Thread子类的run方法中；
实现Runable，线程代码存在接口的子类的run方法
上述程序的分析：
1。通过分析发现：打印票会出现：0，-1，-2等错票；
多线程的运行出现了安全问题：
- 问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句执行了一部分还没有执行完另一个线程已经参与进来了，导致了共享数据的错误
解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完毕，在执行过程中，其他线程不可以执行；（就是说拿到了执行权也不让他执行）
- java对多线程提供了专业的解决方式，就是同步代码块，
synchronized(对象){
需要被同步的代码块，怎么判断哪些代码块需要同步，就看谁操作了共享数据；
}
对象如同锁，持有锁的线程可以在同步中执行，没有持有锁的线程即使获得了CPU的执行权限，也进不去，因为没有获取锁；--理解这个概念可以理解火车上的卫生间；- 同步的前提：
1.必须要有2个或者2个以上的线程；
2.必须多个线程使用一个锁；
必须保证同步中只有一个线程运行，有些需要同步，有些不需要同步；
好处：解决多线程的安全问题；
弊端：每个线程在获取到CPU权限之后，每次都要判断一下锁，这样使程序会变得非常的慢；
package com.wangaling;
class Ticket implements Runnable{
private static int tick=100;
Object obj=new Object();
public void run(){
while (true){
synchronized (obj){
if (tick > 0) {
try(Thread.sleep(10);)catch(Exception e){}
System.out.println(Thread.currentThread().getName() + "sale:" + tick--);
}
}
}
}
}
class TickDemo{
public static void main(String[] args){
// Ticket t1=new Ticket();
// Ticket t2=new Ticket();
// Ticket t3=new Ticket();
// Ticket t4=new Ticket();
// t1.start();
// t2.start();
// t3.start();
// t4.start();
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();
}
}
/*
需求：
银行有一个金库，有两个储户分别存300，每次存100，存3次。
目的：改程序是否有安全问题，如果有，如何解决？
如何找问题：
1.明确哪些代码是多线程运行的代码
2.明确共享数据
3.明确多线程运行代码中哪些语句是操作共享数据的。
*/
class Bank{
private int sum;
Object obj=new Object();
public void add(int n ){
synchronized (obj){
sum=sum+n;
try{Thread.sleep(10);}
catch(Exception e){};
System.out.println("sum="+sum);
}
}
}
class Cus implements Runnable{
private Bank b=new Bank();
public void run(){
for(int x=0;x<3;x++){
b.add(100);
}
}
}
class BankDemo{
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;
// Object obj=new Object();
public synchronized void add(int n ){
// synchronized (obj){
sum=sum+n;
try{Thread.sleep(10);}
catch(Exception e){};
System.out.println("sum="+sum);
// }
}
}
class Cus implements Runnable{
private Bank b=new Bank();
public void run(){
for(int x=0;x<3;x++){
b.add(100);
}
}
}
class BankDemo{
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 Ticket implements Runnable{
private int num=1000;
public synchronized void run(){
while(true) {
if(num>0){
try{
Thread.sleep(10);
}catch (Exception e){}
System.out.println(Thread.currentThread().getName()+"sale"+num--);
}
}
}
}
class ThisLockDemo{
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);
t1.start();
t2.start();
t3.start();
}
}
- 答案不可以，我们可以把run方法体抽离出来单独写一个函数，然后在run里面调用就可以了
class Ticket implements Runnable{
private int num=1000;
public void run(){
while(true){
show();}
}
public synchronized void show(){
if(num>0){
try{
Thread.sleep(10);
}catch (Exception e){}
System.out.println(Thread.currentThread().getName()+"sale"+num--);
}
}
}}
class ThisLockDemo{
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);
t1.start();
t2.start();
t3.start();
}
}
- 上述的例子：同步函数用的哪锁呢？
1.函数需要被对象调用，函数都有一个所属对象的引用，就是this,所以同步函数使用的就是this；
2.通过该程序进行验证，使用两个线程进行卖票，一个线程在同步代码块中，一个在同步函数中，都在执行卖票程序,如果同步不会出现错误的票；
class Ticket implements Runnable{
private int num=1000;
Object obj =new Object();
boolean flag =true;
public void run(){
if (flag){
while(true){
synchronized(this){
if(num>0){
try{
Thread.sleep(10);
}catch (Exception e){}
System.out.println(Thread.currentThread().getName()+"sale"+num--);
}
}
this.show();}
}
}else{
while (true){
show（）；
}
}
public synchronized void show(){
if(num>0){
try{
Thread.sleep(10);
}catch (Exception e){}
System.out.println(Thread.currentThread().getName()+"sale"+num--);
}
}
}}
class ThisLockDemo{
public static void main(String[] args){
Ticket t=new Ticket();
Thread t1= new Thread(t);
Thread t2=new Thread(t);
t1.start();
t1.flag=true;
t2.start();
}
}
- 如果同步函数被静态修饰后，使用的锁是什么呢？
通过发现，不是在是this，因为静态方法也不可以定义this，静态进内存是，内存中没有本类对象，但是一定有该类对应额字节码文件对象；
类名，class，该对象的类型是Class;
静态同步方法，使用的锁是该方法，所在类字节码文件对象，类名class；
class Ticket implements Runnable{
private int num=1000;
boolean flag =true;
public void run(){
if (flag){
while(true){
synchronized(Ticket.class){
if(num>0){
try{
Thread.sleep(10);
}catch (Exception e){}
System.out.println(Thread.currentThread().getName()+"sale"+num--);
}
}
this.show();}
}
}else{
while (true){
show（）；
}
}
public synchronized void show(){
if(num>0){
try{
Thread.sleep(10);
}catch (Exception e){}
System.out.println(Thread.currentThread().getName()+"sale"+num--);
}
}
}}
class ThisLockDemo{
public static void main(String[] args){
Ticket t=new Ticket();
Thread t1= new Thread(t);
Thread t2=new Thread(t);
t1.start();
t1.flag=true;
t2.start();
}
}
死锁：
同步中嵌套同步，而锁确不同；
class Ticket implements Runnable{
private int num=1000;
Object obj=new Object();
boolean flag =true;
public void run(){
if (flag){
while(true){
synchronized(obj){
if(num>0){
try{
Thread.sleep(10);
}catch (Exception e){}
System.out.println(Thread.currentThread().getName()+"sale"+num--);
}
}
this.show();}
}
}else{
while (true){
show（）；
}
}
public synchronized void show(){
synchronized(obj){
if(num>0){
try{
Thread.sleep(10);
}catch (Exception e){}
System.out.println(Thread.currentThread().getName()+"sale"+num--);
}
}
}}
class ThisLockDemo{
public static void main(String[] args){
Ticket t=new Ticket();
Thread t1= new Thread(t);
Thread t2=new Thread(t);
t1.start();
t1.flag=true;
t2.start();
}
}
java学习之- 线程运行状态的更多相关文章
- Java学习笔记 线程池使用及详解
有点笨,参考了好几篇大佬们写的文章才整理出来的笔记.... 字面意思上解释,线程池就是装有线程的池,我们可以把要执行的多线程交给线程池来处理,和连接池的概念一样,通过维护一定数量的线程池来达到多个线程 ...
- java学习之线程
一.线程总述: 线程是java当中一个重要的内容,如果想说线程的话,那我们应该先来讲一下什么是进程. 进程:那么什么是进程呢,进程从字面上来理解就是,正在进行的程序.就比如说我们在windows当中打 ...
- java学习之线程池的实现
package com.gh.threadpoor; import java.util.concurrent.ExecutorService; import java.util.concurrent. ...
- Java 学习笔记 线程控制
题目一 本质上来说,线程是不可控制的,线程的执行是由CPU资源分配决定的,我们无法干预系统CPU的资源分配,但我们可以增加条件来让线程按照我们的预想顺序来执行. 比如.如果当前的执行的线程不满足我们所 ...
- java学习之- 线程继承Thread类
标签(空格分隔): 线程 在java.lang包中有个Thread子类,大家可以自行查阅文档,及范例: 如何在自定义的代码中,自定义一个线程呢? 1.通过对api的查找,java已经提供了对线程这类事 ...
- Java学习：线程池
线程池 线程池概念:其实就是一个容纳多个线程的容器,其中的线程可以反复使用,省去了频繁创建线程对象的操作,无需反复创建线程而消耗过多的资源. 线程池:容器-->集合(ArrayList,Hash ...
- Java学习：线程的安全问题
线程的安全问题 模拟卖票案例创建三个的线程,同时开启,对共享的票进行出售 public class RunnableImpl implementsc Runnable{ //定义一个多线程共享的票源 ...
- Java学习：线程实现方式
线程实现方式 并发与并行 并发:指两或多个事件在同一个时间段内发生 并行:指两或多个事件在同一个时刻发生(同时发生) 进程的概念 内存:所有的应用程序都需要进入到内存中执行 临时存储RAM 硬盘:永久 ...
- java学习笔记 - 线程池（一）
线程池(Thread Pool):把一个或多个线程通过统一的方式进行调度和重复使用的技术,避免了因为线程过多而带来使用上的开销 优点:(面试题)可重复使用已有线程,避免对象创建.消亡和过度切换的性能开 ...
随机推荐
- 万能RecyclerView的数据适配器BaseRecyclerViewAdapterHelper
今天楼主才发现github上有这么一个好用的开源代码,充满好奇心的楼主马上使用了,特地分享给大家. 此项目的github地址: https://github.com/CymChad/BaseRecyc ...
- 简单分析线程获取ReentrantReadWriteLock 读锁的规则
1. 问题 最近有同事问了我一个问题,在Java编程中,当有一条线程要获取ReentrantReadWriteLock的读锁,此时已经有其他线程获得了读锁,AQS队列里也有线程在等待写锁.由于读锁是共 ...
- JVM（一）：久识你名，初居我心
聊聊JVM JVM,一个熟悉又陌生的名词,从认识Java的第一天起,我们就会听到这个名字,在参加工作的前一两年,面试的时候还会经常被问到JDK,JRE,JVM这三者的区别. JVM可以说和我们是老朋友 ...
- 入门训练-4. Fibonacci数列
问题描述 Fibonacci数列的递推公式为:Fn=Fn-1+Fn-2,其中F1=F2=1. 当n比较大时,Fn也非常大,现在我们想知道,Fn除以10007的余数是多少. 输入格式 输入包含一个整数n ...
- Gordon家族（一）
引子 Go语言的吉祥物是一只囊地鼠(gopher),由插画师Renee French设计,名叫Gordon,长得这个样子: 在Go官网上(https://golang.google.cn/)的Gord ...
- Android的简述3
Activity的生命周期 Activity类中有许多onXXX形式的函数可以重载,比如onCreate,onStart,onStop,onPause,那么它们的调用顺序到底是如何的呢?下面就通过一个 ...
- web设计_1_思路总览
核心思想:结构和样式分离 HTML与CSS 只有充分将页面核心内容和外观设计相分离而获得的灵活性,才能顺利构建出能够满足每个web用户需要的最佳设计方案. 核心要求:灵活性 适应不同的浏览器,适应各种 ...
- es6，@import一直报错 Can't resolve。。
最近在项目中新增了一个按钮组的组件页面,但是在其他页面引入时,一直报错 引入方式:
- 【iOS】沙盒目录
有关沙盒目录参考: http://blog.csdn.net/totogo2010/article/details/7669837 获取沙盒路径,参考代码: NSArray *paths = NSSe ...
- RGB颜色 三者都是0为黑色而255是白色 解释
问题: RGB颜色 都是0为黑色而255是白色 与日常生活的黑色白色差距怎么那么大,(与物理学中的黑色吸收光是否相悖)而且为什么要这样定义呢? 链接:https://www.zhihu.com/que ...