Java Day 13

线程的状态
被创建运行冻结消亡

被创建--start()--> 运行
运行----run()----> 消亡
         stop()
运行---sleep(time)---> 冻结
        wait()-->
        <--notify()

cpu 执行资格被cup处理、处于队列中
cpu 执行权   正在被cpu处理

创建线程的第二种方法
实现Runnable接口

Thread t1 = new Thread(d)//d是实现Runnable接口类创建的对象
1、定义类实现Runnable接口
2、覆盖接口中的run方法，将线程任务封装
3、通过Thread类创建线程对象，将对象作为线程构造函数的参数进行传递
4、调用线程对象的start方法

细节
单独进行封装

线程安全问题
1、多线程操作共享数据
2、操作共享数据的线程代码有多条

同步代码块
将多条操作共享数据的线程代码封装起来，只允许一个线程访问
synchronized(对象){ 代码 }

同步代码块利弊
利解决了线程的安全问题
弊效率降低

同步的前提同步中必须有多个线程使用同一个锁

同步函数

同步函数的锁
同步函数使用的锁是this

静态同步函数的锁
函数所属字节码文件对象
this.getClass();
类.class

 1 class Ticket implements Runnable{ //extends Thread
 2     private int num = 100;
 3     Object obj = new Object();
 4     boolean flag = true;
 5
 6     public void run(){
 7         //Object obj = new Object();
 8         if(flag){
 9             while(true){
10                 show();
11                 if(num==0)
12                     return;
13             }
14         }else{
15             while(true){
16                 synchronized(this){
17                     if(num>0){
18                         try{
19                             Thread.sleep(10);
20                         }catch(InterruptedException e){
21                         }
22                     System.out.println(Thread.currentThread().getName()+"...block..."+num--);
23                     }
24             }
25                 if(num==0)
26                     return;
27             //}
28             }
29         }
30
31     }
32
33     public synchronized void show(){
34         if(num>0){
35             try{
36                 Thread.sleep(10);
37             }catch(InterruptedException e){    }
38             System.out.println(Thread.currentThread().getName()+"...func..."+num--);
39         }
40     }
41 }
42
43
44 public class SaleTicketsDemo{
45     public static void main(String[] args){
46         /*Ticket t1 = new Ticket();
47         Ticket t2 = new Ticket();
48         Ticket t3 = new Ticket();
49         Ticket t4 = new Ticket();
50
51         t1.start();
52         t2.start();
53         t3.start();
54         t4.start();*/
55         Ticket t = new Ticket();
56         Thread t1 = new Thread(t);
57         Thread t2 = new Thread(t);
58
59         t1.start();
60         try{Thread.sleep(10);}catch(InterruptedException e){    }
61         t.flag = false;
62         t2.start();
63
64     }
65 }

单例模式的多线程问题

 1 class Single{
 2     private static Single s = null;
 3     private Single(){}
 4     public static Single getInstance(){
 5         if(s==null){
 6             synchronized(Single.class){
 7                 if(s==null){
 8                     s = new Single();
 9                 }
10             }
11         }
12         return s;
13     }
14 }

死锁
1、同步的嵌套

 1 class Test implements Runnable{
 2     private boolean flag;
 3     Test(boolean blag){
 4         this.flag = flag;
 5     }
 6     public void run(){
 7         if(flag){
 8             while(true){
 9                 synchronized(MyLock.locka){
10                     System.out.println(Thread.currentThread().getName()+"  if  locka...");
11                     synchronized(MyLock.lockb){
12                         System.out.println(Thread.currentThread().getName()+"  if  lockb...");
13                     }
14                 }
15             }
16         }else{
17             while(true){
18                 synchronized(MyLock.lockb){
19                     System.out.println(Thread.currentThread().getName()+"  else  lockb...");
20                     synchronized(MyLock.locka){
21                         System.out.println(Thread.currentThread().getName()+"  else  locka...");
22                     }
23                 }
24             }
25         }
26     }
27 }
28 class MyLock{
29     public static final Object locka = new Object();
30     public static final Object lockb = new Object();
31 }
32 class DeadLockTest{
33     public static void main(String[] args){
34         Test a = new Test(true);
35         Test b = new Test(false);
36
37         Thread t1 = new Thread(a);
38         Thread t2 = new Thread(b);
39         t1.start();
40         t2.start();
41     }
42 }

View Code

转载于:https://www.cnblogs.com/zhuzhuqwa/p/5907516.html

Java Day 13相关推荐

Java的13个规范
Java的13个规范一流企业做标准.二流企业做品牌.三流企业做产品! 规范:意指明文规定或约定俗成的标准,或是指按照既定标准.规范的要求进行操作,使某一行为或活动达到或超越规定的标准. J2EE中也 ...
Java基础13：反射与注解详解
Java基础13:反射与注解详解什么是反射? 反射(Reflection)是Java 程序开发语言的特征之一,它允许运行中的 Java 程序获取自身的信息,并且可以操作类或对象的内部属性. Orac ...
JAVA SE 13快速安装
1.JAVA SE 13下载链接地址: https://www.oracle.com/technetwork/java/javase/downloads/jdk13-downloads-5672538 ...
Thinking in java 第13章字符串笔记+习题
Thinking in java 第13章字符串学习目录 13.1 不可变String 13.2 重载"+"与StringBuilder 1. 用于String的"+ ...
JAVA必备——13个核心规范
标准的价值: 你听过这句话吗?"一流企业做标准.二流企业做品牌.三流企业做产品!"我时我就在想,做标准的企业就是一流的?卖产品就是三流公司?而坐产品或者加工的公司,即使说销售量非常 ...
Java虚拟机13：Java类加载机制
前言我们知道我们写的程序经过编译后成为了.class文件,.class文件中描述了类的各种信息,最终都需要加载到虚拟机之后才能运行和使用.而虚拟机如何加载这些.class文件?.class文件的信息 ...
int arr 13 java,java学习13 - 数组的定义、操作、异常、二维数组
续java学习12: 1.数组,引用类型变量,保存数据实际是保存的数组的首地址 2.定义数组容器三要素,数据类型,大小(长度),数组名 3.数组的定义公式一:数据类型[] 数组名 = new 数据类型 ...
韩顺平循序渐进学java 第13讲抽象类.接口
13.1抽象类 13.1.1 概念当父类的一些方法不能确定时,可以用abstract关键字来修饰该方法,称为抽象方法,用abstract来修饰该类,称为抽象类. 13.1.2 抽象类-深入讨论抽象 ...
java开发13寸_Java 从入门到进阶之路（二十九）
在之前的文章我们已经可以对本地对文件和目录进行新建和删除等操作,接下来我们来对文件内对具体内容进行操作. 如下代码,我们实现了一个基本的文件写入: 1 /** 2 * java.io.RandomAc ...
Java 生成13位条形码 Ean-13码规则：第十三位数字是前十二位数字经过计算得到的校验码。
package cn.zhang;import java.util.Scanner;public class Subject001 {/**生成13位条形码 Ean-13码规则:第十三位数字是前十二位 ...

Java Day 13

Java Day 13相关推荐

最新文章

热门文章