------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
package cn.fuxi._01Object;
/**
* Object:所以类的根类.
* object是不断抽取而来,具备着左右对象都具备的共性内容.
*
* P.S. ==以及Object类的equals方法默认都是根据对象的哈希值判断两个对象是否相等.
* 可以通过覆盖Object的equals来重写比较规则
*
* Object类的toString方法默认返回的内容时"对象所属的类名+@+对象的哈希值(十六进制)".
*/
class Person{
private int age;
Person(int age){
this.age = age;
}
public int hashCode(){
return age;
}
}
class Person1{
private int age;
Person1(int age){
this.age=age;
}
//比较Person的年龄,是否是同龄人
//一般都会覆盖此方法,根据对象的特有内容,建立判断对象是否相同的依据.
public boolean equals(Object obj){
if(!(obj instanceof Person1)){
throw new ClassCastException("类型错误");
}
Person1 p = (Person1)obj;
return this.age==p.age;
}
}
class Demo{}
public class ObjrctDemo1 {
public static void main(String[] args) {
/* Person p1 = new Person(10);
Person p2 = new Person(20);
Person p3 = p1;
Demo d = new Demo();
System.out.println(p1==p2);//f
System.out.println(p1.equals(p2));//f
System.out.println(p1.equals(p3));//t
System.out.println(p1.equals(d));//f
*/
Person1 p1 = new Person1(20);
Person1 p2 = new Person1(20);
System.out.println(p1.equals(p2));//t
System.out.println(p1.toString());
Person p = new Person(19);
System.out.println(p);
System.out.println(p.getClass().getName()+"$"+
Integer.toHexString(p.hashCode()));
System.out.print(p.getClass().getName());
System.out.print("@");
System.out.print(Integer.toHexString(p.hashCode()));
}
}
运行结果:
true
cn.fuxi._01Object.Person1@75f10df7
cn.fuxi._01Object.Person@13
cn.fuxi._01Object.Person$13
cn.fuxi._01Object.Person@13
包:
package packa;
public class DemoA extends packb.DemoB {
public void show(){
method();
System.out.println("demoa run show");
}
}
package packb;
public class DemoB {
protected void method(){
System.out.println("demob show run");
}
}
package cn.fuxi.packagedemo;
/**
* 包
* 对类文件进行分类管理.
* 给类提供多层命名空间.
* 写在程序文件的第一行.
*
* 类名的全称是:包名.类名.
* 包也是一种封装形式.
* P.S. 包与包之间的类进行访问,被访问的宝中的类必须是public的,
* 被访问的包中的类的方法也必须是public的.
*
* 包之间的访问:被访问的包中的类权限必须是public的.
* 类中的成员权限:public或者protected.
* protected是为其他包中的子类提供的一种权限.
*
* 四种权限:
* public protected default private
* 同一类中 f f f f
* 同一包中 f f f
* 子类 f f
* 不同包中 f
*
* import
* 一个程序文件中只有一个package,但可以有多个import.
*/
//import packa.DemoA;导入包中某一类
//import packb.DemoB;
import packa.*;//导入包中所有类
public class PackageDemo {
public static void main(String[] args) {
DemoA da = new DemoA();
da.show();
}
}
/*
* 例:
* 有两个类:DemoA,DemoAbc.
* 所在文件目录如下:
* packa\DemoA.class
* packa\abc\DemoAbc.class
*
* 导包语句如下:
* import packa.*;
* import packa.abc.*;
*
* jar包
* java的压缩包.
* 方便项目的携带.
* 方便于使用,只要在classpath设置jar路径即可.
* 数据库驱动,SSH框架等都是以jar包体现的.
*
* jar包的操作:
* 通过jar.exe工具对jar的操作.
*
* 创建jar包:
* jar-cvf mypack.jar packa packb
* 查看jar包:
* jar-tvf mypack.jar [>定向文件]
* 解压缩:
* jar -xvf mypack.jar
* 自定义jar包的清单文件
* jar -cvfm mypack.jar mf.txt packa packb
*/
运行结果:
demob show run
demoa run show
多线程的概念:
package cn.fuxi.duoxiancheng;
/**
* 多线程
* 进程 线程 多进程的概念
* 进程:正在经行中的程序(直译)
* 线程:进程中一个负责程序执行的控制单元(执行路径).
*
* P.S.
* 1.一个进程中可以有多个执行路径,称之为多线程.
* 2.一个进程中至少要有一个线程.
* 3.开启多个线程是为了同时运行多部分代码,每一个线程都有自己运行的内容,
* 这个内容可以成为线程要执行的任务.
*
* 多线程的好处:解决了多部分代码同时运行的问题.
* 多线程的弊端:线程太多,会导致效率的降低.
* 其实,多个应用程序同时执行都是CPU在做着快速的切换完成的.这个切换是随机的.
* CPU的切换是需要花时间的,从而导致了效率的降低.
*
* JVM启动时启动了多条线程,至少有两个线程可以分析的出来:
* 1.执行main函数的线程,该线程的任务代码都定义在main函数中.
* 2.赋值垃圾回收的线程.
*/
class Demo extends Object{
public void finalize(){
System.out.println("demo ok");
}
}
public class DuoXianChengDemo {
public static void main(String[] args) {
new Demo();
new Demo();
new Demo();
System.gc();//表示告诉垃圾回收器调用finalize,把垃圾收走,不一定立即执行
System.out.println("Hello World!");
}
}
运行结果:
Hello World!
demo ok
demo ok
demo ok
package cn.fuxi.duoxiancheng;
/**
* 创建线程方式之一:继承Thread类
* 1.定义一个类继承Thread类.
* 2.覆盖Thread类中的run方法.
* 3.直接创建Thread的子类对象创建线程.
* 4.调用start方法开启线程并调用线程的任务run方法执行.
*/
/*
*在单线程程序中,只有上一句代码执行完,下一句代码才有执行机会.
*创建线程的目的就是为了开启一条执行路径,去运行指定的代码和其他代码实现同时运行,而运行的指定代码
*就是这个执行路径的任务.
*
*jvm创建的主线程的任务都定义在了主函数中.而自定义的线程,它的任务在哪儿呢?
*Thread类用于描述线程,线程是需要任务的.所以Thread类也有对任务的描述.这个任务就是通过Thread类
*中的run方法来体现.也就是说,run方法就是封装自定义线程运行任务的函数,run方法中定义的就是线程要运
*行的任务代码.
*
*开启线程是为了运行指定代码,所以只有继承Thread类,并复写run方法,将运行的代码定义在run方法中即可.
*
*/
//单线程示例
class Demo1{
private String name;
Demo1(String name){
this.name = name;
}
public void show(){
for(int x = 0;x<10;x++){
System.out.println(name + "..x="+x);
}
}
}
class Demo2 extends Thread{
private String name;
Demo2(String name){
this.name = name;
}
public void run(){
for(int x = 0;x<10;x++){
System.out.println(name + "...x= " + x +
"...ThreadName= "+Thread.currentThread().getName());
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
/* Demo1 d1 = new Demo1("小白");
Demo1 d2 = new Demo1("小强");
d1.show();//单线程
d2.show();
*/
Demo2 d1 = new Demo2("旺财");
Demo2 d2 = new Demo2("强哥");
d1.start();
d2.start();
for(int x = 0; x<10; x++){
System.out.println("x = " +x+"...over..."+
Thread.currentThread().getName());
}
}
}
/*
*1.可以通过Thread的getName()方法获取线程的名称,名称格式:Thread-编号(从0开始).
*2.Thread在创建的时候该Thread就已经命名到了.
*/
运行结果:
x = 0...over...main
x = 1...over...main
x = 2...over...main
旺财...x= 0...ThreadName= Thread-0
强哥...x= 0...ThreadName= Thread-1
旺财...x= 1...ThreadName= Thread-0
x = 3...over...main
旺财...x= 2...ThreadName= Thread-0
强哥...x= 1...ThreadName= Thread-1
旺财...x= 3...ThreadName= Thread-0
x = 4...over...main
旺财...x= 4...ThreadName= Thread-0
强哥...x= 2...ThreadName= Thread-1
旺财...x= 5...ThreadName= Thread-0
x = 5...over...main
旺财...x= 6...ThreadName= Thread-0
强哥...x= 3...ThreadName= Thread-1
旺财...x= 7...ThreadName= Thread-0
x = 6...over...main
旺财...x= 8...ThreadName= Thread-0
强哥...x= 4...ThreadName= Thread-1
旺财...x= 9...ThreadName= Thread-0
x = 7...over...main
x = 8...over...main
x = 9...over...main
强哥...x= 5...ThreadName= Thread-1
强哥...x= 6...ThreadName= Thread-1
强哥...x= 7...ThreadName= Thread-1
强哥...x= 8...ThreadName= Thread-1
强哥...x= 9...ThreadName= Thread-1
package cn.fuxi.duoxiancheng;
/**
* 创建线程方式二:实现Runnable接口
* 1.定义类实现Runnable接口.
* 2.覆盖接口中的run方法,将线程的任务代码封装到run方法中.
* 3.通过Thread类创建线程对象,并将Runnable接口的子类对象作为Thread类的构造函数
* 的参数经行传递.为什么?因为线程的任务都封装在Runnable接口子类对象的run方法中.所以
* 要在线程对象创建时就必须明确要运行的任务.
* 4.调用线程对象的start方法开启线程.
*
* 实现Runnable接口的好处:
* 1.将线程的任务从线程的子类中分离出来.经行了单独的封装,安装面向对象的思想将任务封装成
* 对象.
* 2.避免了java单继承的局限性.所以,创建线程的第二种方式较为常用.
*/
//准备拓展Demo类的功能,让其中的内容可以作为线程的任务执行.
//通过接口的形式完成.
class Demo3 implements Runnable{
public void run(){
show();
}
public void show(){
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+"..."+i);
}
}
}
public class ThreadDemo2 {
public static void main(String[] args) {
Demo3 d = new Demo3();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
t2.start();
}
}
运行结果:
Thread-1...0
Thread-0...0
Thread-1...1
Thread-0...1
Thread-1...2
Thread-0...2
Thread-1...3
Thread-0...3
Thread-1...4
Thread-0...4
Thread-1...5
Thread-0...5
Thread-1...6
Thread-0...6
Thread-1...7
Thread-0...7
Thread-1...8
Thread-0...8
Thread-1...9
Thread-0...9
Thread-1...10
Thread-0...10
Thread-1...11
Thread-0...11
Thread-1...12
Thread-0...12
Thread-1...13
Thread-0...13
Thread-1...14
Thread-0...14
Thread-1...15
Thread-0...15
Thread-1...16
Thread-0...16
Thread-1...17
Thread-0...17
Thread-1...18
Thread-0...18
Thread-1...19
Thread-0...19
package cn.fuxi.duoxiancheng;
/**
* Thread类 Runnable接口内部源码关系模拟代码:
*/
class Thread1{
private Runnable r;
Thread1(){}
Thread1(Runnable r){
this.r = r;
}
public void run(){
if(r!=null){
r.run();
}
}
public void start(){
run();
}
}
class ThreadImpl implements Runnable{
public void run(){
System.out.println("runnable run");
}
}
class SubThread extends Thread1{
public void run(){
System.out.println("hahaha");
}
}
public class ThreadDemo3 {
public static void main(String[] args) {
ThreadImpl i = new ThreadImpl();
Thread1 t = new Thread1(i);
t.start();
SubThread st = new SubThread();
st.start();
}
}
运行结果:
runnable run
hahaha
模拟卖票:
package cn.fuxi.duoxiancheng;
/**
* 线程安全问题:
* 模拟4个线程同时卖100张票.
*/
class Ticket implements Runnable{
private int num = 100;
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--);
}
}
}
}
public class ThreadDemo4 {
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();
//会售出重复的,还有负数的票
}
}
/*
*原因分析:
*出现上述安全问题的原因在于thread-0通过了if判断后,在执行到"num--"语句之前,num此时仍等于1.
*CPU切换到Thread-1 Thread-2 Thread-3 之后,这些线程依然可以通过if判断,从而执行"num--"的
*操作,因而出现了0 -1 -2的情况.
*/
运行结果:
Thread-0...sale...8
Thread-3...sale...7
Thread-1...sale...6
Thread-2...sale...4
Thread-0...sale...5
Thread-3...sale...6
Thread-0...sale...3
Thread-2...sale...2
Thread-3...sale...2
Thread-1...sale...3
Thread-0...sale...1
Thread-1...sale...-1
Thread-3...sale...0
Thread-2...sale...1
package cn.fuxi.duoxiancheng;
/**
* 线程安全问题产生的原因:
* 1.多个线程在操作共享的数据.
* 2.操作共享数据的线程代码有多条.
* 当一个线程在执行操作共享数据的多条代码过程中,其他线程参与了运算,就会导致线程安全问题的产生.
*
* 线程安全问题的解决方案
* 思路:
* 就是将多条操作共享数据的线程代码封装起来,当有线程在执行这些代码的时候,其他线程不可以参与运算.
* 必须要当前线程把这些代码都执行完毕后,其他线程才可以参与运算.
*
* 在java中,用同步代码块就可以解决这个问题.
* 同步代码块的格式:
* synchronized(对象){
* 需要被同步的代码;
* }
*
* 同步的好处:解决了线程的安全问题.
* 同步的弊端:当线程相当多时,因为每个线程都会去判断同步上的锁,这是很耗费资源的,无形中会降低程序的运行效率.
* 同步的前提:必须有多个线程并使用同一个锁.
*/
class Ticket2 implements Runnable{
private int num = 100;
Object obj = new Object();
public void run(){
while(true){
synchronized(obj){
if(num>0){
System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
}
}
}
}
}
public class ThreadDemo5 {
public static void main(String[] args) {
Ticket2 t = new Ticket2();
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();
}
}
/*
* 原因分析:
* 上图显示安全问题已被解决,原因在于Object对象相当于是一把锁,只有抢到锁的线程,才能进入同步代码块向下执行.
* 因此,当num=1时,CPU切换到某个线程后,如上面的Thread-3线程,其他线程无法通过同步代码块进行if判断语句,只
* 有等到Thread-3线程执行完"num--"的操作(此后的值为0),并跳出同步代码块后,才能抢到锁.其他线程即使抢到锁,
* 然而,此时num值已经为0,也就无法通过if语句判断,从而无法再执行"num--"的操作了,也就不会出现0,-1,-2的情况
* 了.
*/
运行结果:
Thread-1...sale...10
Thread-1...sale...9
Thread-1...sale...8
Thread-1...sale...7
Thread-1...sale...6
Thread-1...sale...5
Thread-1...sale...4
Thread-1...sale...3
Thread-1...sale...2
Thread-1...sale...1
同步代码块:
package cn.fuxi.duoxiancheng;
/**
* 利用同步代码块解决安全问题
* 需求:储户,两个,每个都到银行存钱,每次存100,共三次.
* 安全问题的第一种解决方案:同步代码块;
* 安全问题的第二种解决方案:同步函数.
*
* 同步函数和同步代码块的区别:
* 1.同步函数的锁固定是this
* 2.同步代码块的锁是任意的对象.
* 建议使用同步代码块.
*/
//同步代码块
class Bank{
private int sum;
public void add(int num){
synchronized(this){
sum = sum +num;
System.out.println("sum = "+sum);
}
}
}
//同步函数
class Bank2{
private int sum;
public synchronized void add(int num){
sum = sum +num;
System.out.println("sum = "+sum);
}
}
class Cus implements Runnable{
private Bank b = new Bank();
public void run(){
for (int i = 0; i < 3; i++) {
b.add(100);
}
}
}
class Cus2 implements Runnable{
private Bank2 b2 = new Bank2();
public void run(){
for (int i = 0; i < 3; i++) {
b2.add(100);
}
}
}
public class ThreadDemo6 {
public static void main(String[] args) {
Cus c = new Cus();
Thread t1 = new Thread(c);
Thread t2 = new Thread(c);
t1.start();
t2.start();
Cus2 c2 = new Cus2();
Thread tt1 = new Thread(c2);
Thread tt2 = new Thread(c2);
tt1.start();
tt2.start();
}
}
/*
*原因分析:
*由代码中可以看到,同步代码块中的语句,存在可能有多个线程同时操作共享数据(sum)的情况,通过同步代码
*块即可解决存在的安全问题.
*/
运行结果:
sum = 100
sum = 200
sum = 300
sum = 400
sum = 500
sum = 600
sum = 100
sum = 200
sum = 300
sum = 400
sum = 500
sum = 600
package cn.fuxi.duoxiancheng;
/**
* 由于同步函数的锁是固定的this,同步代码块的锁是任意的对象,
* 那么如果同步函数和同步代码块都使用this作为锁,就可以实现同步.
*/
class Ticket3 implements Runnable{
private int num = 100;
boolean flag =true;
public void run(){
if(flag){
while(true){
synchronized(this){
if(num>0){
try {
Thread.sleep(100);
} 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(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"...function..."+num--);
}
}
}
public class ThreadDemo7 {
public static void main(String[] args) {
Ticket3 t = new Ticket3();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//上面这条语句一定要执行,应为可能线程t1未真正启动,flag已经设置为false,那么当t1执行的时候,
//就会按照flag为false的情况执行,线程t2也按照false执行,就达不到试验的目的了.
t.flag = false;
t2.start();
}
}
运行结果:
Thread-1...function...15
Thread-1...function...14
Thread-1...function...13
Thread-1...function...12
Thread-1...function...11
Thread-1...function...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-1...function...2
Thread-1...function...1
package cn.fuxi.duoxiancheng;
/**
* 静态的同步函数使用的锁是该函数所属字节码文件对象,可以用getClass方法获取,也可以用当前类名.class表示.
*/
class Ticket4 implements Runnable{
private static int num = 100;
Object obj = new Object();
boolean flag = true;
public void run(){
if(flag){
while(true){
synchronized(Ticket4.class){//this.getClass()
if(num>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"...obj..."+num--);
}
}
}
}else{
while(true){
show();
}
}
}public static synchronized void show(){
if(num>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"...function..."+num--);
}
}
}
public class ThreadDemo8 {
public static void main(String[] args) {
Ticket4 t = new Ticket4();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
t.flag = false;
t2.start();
}
}
运行结果:
Thread-1...function...21
Thread-1...function...20
Thread-1...function...19
Thread-1...function...18
Thread-0...obj...17
Thread-1...function...16
Thread-1...function...15
Thread-1...function...14
Thread-0...obj...13
Thread-1...function...12
Thread-1...function...11
Thread-1...function...10
Thread-1...function...9
Thread-1...function...8
Thread-1...function...7
Thread-1...function...6
Thread-1...function...5
Thread-1...function...4
Thread-1...function...3
Thread-0...obj...2
Thread-1...function...1
多线程下的单例模式问题:
package cn.fuxi.duoxiancheng;
/**
* 多线程下的单里模式
*/
//P.S.饿汉式不存在安全问题,因为不存在多个线程共同操作数据的情况.
class Single{
private Single(){}
private static final Single s = new Single();
public static Single getInstance(){
return s;
}
}
//懒汉式存在安全问题,可以使用同步函数解决.
//但若直接使用同步函数,则效率较低,因为每次都需要判断.
class Single2{
private Single2(){}
private static Single2 s =null;
public static Single2 getInstance(){
if(s==null){
synchronized(Single2.class){
if(s==null)
s = new Single2();
}
}
return s;
}
}
/*
*原因在于任何一个线程在执行到第一个if判断语句时,如果Single对象已经创建,则直接获取即可,
*而不用判断是否能够获取锁,相对于上面使用同步函数的方法就提升了效率.如果当前线程发现Single
*对象尚未创建,则再判断是否能够获取锁.
*1.如果能够获取锁,那么久通过第二个if判断语句判断是否需要Single对象.因为可能当此线程获
*取到锁之前,已经有一个线程创建完Single对象,并且放弃了锁.此时,它便没有必要再去创建,可以
*直接跳出同步代码块,放弃锁,获取Single对象即可.如果有必要,则再创建.
*2.如果不能获取到锁,则等待,直到能够获取到锁为止,再按步骤一执行.
*/
public class ThreadDemo9 {
public static void main(String[] args) {
}
}
死锁问题:
package cn.fuxi.duoxiancheng;
/**
* 死锁案列:同步的嵌套
*/
class Ticket5 implements Runnable{
private static int num = 100;
Object obj = new Object();
boolean flag = true;
public void run(){
if(flag){
while(true){
synchronized(obj){
show();
}
}
}else {
while(true){
show();
}
}
}
public synchronized void show(){
synchronized(obj){
if(num>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"...function..."+num--);
}
}
}
}
public class ThreadDemo10 {
public static void main(String[] args) {
Ticket5 t = new Ticket5();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
t.flag = false;
t2.start();
}
}
/*
*程序运行后可以看出,程序已被锁死,无法向下执行.
*由代码可以看出,run方法中的同步代码块需要获取obj对象锁,才能执行代码块中的show方法.
*而执行show方法则必须获取this对象锁,然后才能执行其中的同步代码块.
*当线程t1获取到obj对象锁执行同步代码块,线程t2获取到this对象锁执行show方法.同步
*代码块中的show方法因无法获取到this对象锁无法执行,show方法中的同步代码块因为无法获取
*到obj对象锁无法执行,就会产生死锁.
*/
运行结果:
Thread-1...function...63
Thread-1...function...62
Thread-1...function...61
Thread-1...function...60
Thread-1...function...59
Thread-1...function...58
Thread-0...function...57//停止了
死锁2:
package cn.fuxi.duoxiancheng;
/**
* 死锁2
*/
class Test implements Runnable{
private boolean flag;
Test(boolean flag){
this.flag = flag;
}
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{
while(true){
synchronized(MyLock.lockb){
System.out.println(Thread.currentThread().getName()+"...else lockb...");
synchronized(MyLock.locka){
System.out.println(Thread.currentThread().getName()+"...else locka...");
}
}
}
}
}
}
class MyLock{
public static final Object locka = new Object();
public static final Object lockb = new Object();
}
public class ThreadDemo11 {
public static void main(String[] args) {
Test a = new Test(true);
Test b = new Test(false);
Thread ta = new Thread(a);
Thread tb = new Thread(b);
ta.start();
tb.start();
}
}
运行结果:
Thread-1...else lockb...
Thread-0...if locka...