黑马程序员——Java基础——Object，包和多线程基础（一）

------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);//fSystem.out.println(p1.equals(p2));//fSystem.out.println(p1.equals(p3));//tSystem.out.println(p1.equals(d));//f*/Person1 p1 = new Person1(20);Person1 p2 = new Person1(20);System.out.println(p1.equals(p2));//tSystem.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是为其他包中的子类提供的一种权限. *  * 四种权限: * publicprotecteddefaultprivate * 同一类中ffff * 同一包中fff * 子类ff * 不同包中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...