黑马程序员--包、多线程

                   -----------android培训、java培训、java学习型技术博客、期待与您交流！------------

包、多线程

包：定义包用package关键字。

1：对类文件进行分类管理。

2：给类文件提供多层名称空间。

 

如果生成的包不在当前目录下，需要最好执行classpath，将包所在父目录定义到classpath变量中即可。

一般在定义包名时，因为包的出现是为了区分重名的类。所以包名要尽量唯一。怎么保证唯一性呢？可以使用url域名来进行包名称的定义。

package pack;//定义了一个包，名称为pack。 注意：包名的写法规范：所有字母都小写。

//package cn.itcast.pack.demo;

 

类的全名称是 包名.类名

    编译命令：javac –d 位置（.当前路径） java源文件 （就可以自动生成包）

 

包是一种封装形式，用于封装类，想要被包以外的程序访问，该类必须public；

1.类中的成员，如果被包以外访问，也必须public；

2.不同包中的子类还可以直接访问父类中被protected修饰的成员。

 

包与包之间访问可以使用的权限有两种：

1：public 

2：protected：只能是不同包中的子类可以使用的权限。

 

总结java中的四种权限：

    范围       public protected default private 

同一个类中       ok ok ok ok

同一包中  ok ok ok

子类  ok  

不同包中         ok

-----------------------------------------------------------------------------------------------

Import - 导入：类名称变长，写起来很麻烦。为了简化，使用了一个关键字：import，可以使用这个关键字导入指定包中的类。记住：实际开发时,到的哪个类就导入哪个类，不建议使用*.

import packa.*;//这个仅仅是导入了packa当前目录下的所有的类。不包含子包。

import packa.abc.*;//导入了packa包中的子包abc下的当前的所有类。

 

如果导入的两个包中存在着相同名称的类。这时如果用到该类，必须在代码中指定包名。

 

常见的软件包:

java.lang : language java的核心包，Object System  String Throwable jdk1.2版本后，该包中的类自动被导入。

java.awt : 定义的都是用于java图形界面开发的对象。

javax.swing: 提供所有的windows桌面应用程序包括的控件,比如：Frame , Dialog, Table, List 等等,就是java的图形界面库。

java.net : 用于java网络编程方面的对象都在该包中。

java.io : input  output 用于操作设备上数据的对象都在该包中。比如：读取硬盘数据，往硬盘写入数据。

java.util : java的工具包，时间对象，集合框架。

java.applet: application+let 客户端java小程序。server+let  -->  servlet 服务端java小程序。

 

jar ：java的压缩包，主要用于存储类文件，或者配置文件等。

命令格式：

创建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

多线程：★★★★

进程：正在进行中的程序。其实进程就是一个应用程序运行时的内存分配空间。

线程：其实就是进程中一个程序执行控制单元，一条执行路径。进程负责的是应用程序的空间的标示。线程负责的是应用程序的执行顺序。

 

一个进程至少有一个线程在运行，当一个进程中出现多个线程时，就称这个应用程序是多线程应用程序，每个线程在栈区中都有自己的执行空间，自己的方法区、自己的变量。

jvm在启动的时，首先有一个主线程，负责程序的执行，调用的是main函数。主线程执行的代码都在main方法中。

当产生垃圾时，收垃圾的动作，是不需要主线程来完成，因为这样，会出现主线程中的代码执行会停止，会去运行垃圾回收器代码，效率较低，所以由单独一个线程来负责垃圾回收。 

 

随机性的原理：因为cpu的快速切换造成，哪个线程获取到了cpu的执行权，哪个线程就执行。

 

返回当前线程的名称：Thread.currentThread().getName()

线程的名称是由：Thread-编号定义的。编号从0开始。

线程要运行的代码都统一存放在了run方法中。

 

线程要运行必须要通过类中指定的方法开启。start方法。（启动后，就多了一条执行路径）

start方法：1）、启动了线程；2）、让jvm调用了run方法。

 

创建线程的第一种方式：继承Thread ，由子类复写run方法。

步骤：

1，定义类继承Thread类；

2，目的是复写run方法，将要让线程运行的代码都存储到run方法中；

3，通过创建Thread类的子类对象，创建线程对象；

4，调用线程的start方法，开启线程，并执行run方法。

 

线程状态：

被创建：start()

运行：具备执行资格，同时具备执行权；

冻结：sleep(time),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格；

临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权；

消亡：stop()

 

创建线程的第二种方式：实现一个接口Runnable。

步骤：

1，定义类实现Runnable接口。

2，覆盖接口中的run方法（用于封装线程要运行的代码）。

3，通过Thread类创建线程对象；

4，将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。

为什么要传递呢？因为要让线程对象明确要运行的run方法所属的对象。

5，调用Thread对象的start方法。开启线程，并运行Runnable接口子类中的run方法。

Ticket t = new Ticket();

/*

直接创建Ticket对象，并不是创建线程对象。

因为创建对象只能通过new Thread类，或者new Thread类的子类才可以。

所以最终想要创建线程。既然没有了Thread类的子类，就只能用Thread类。

*/

Thread t1 = new Thread(t); //创建线程。

/*

只要将t作为Thread类的构造函数的实际参数传入即可完成线程对象和t之间的关联

为什么要将t传给Thread类的构造函数呢？其实就是为了明确线程要运行的代码run方法。

*/

t1.start();

package pack;
// 练习：创建两个线程，和主线程交替运行。
class Test extends Thread{
	private String name;
	Test(String name){
		this.name=name;
	}
	public void run(){
		for(int x=0; x<50; x++)
			System.out.println("run: "+x+" :"+name);
	}
}
class ThreadTest1{
	public static void main(String[] args){
		Test t1=new Test("男神");
		Test t2=new Test("女神");
		t1.start();t2.start();
		for(int x=0; x<50; x++)
			System.out.println("main :"+x);
	}
}

为什么要有Runnable接口的出现？

1：通过继承Thread类的方式，可以完成多线程的建立。但是这种方式有一个局限性，如果一个类已经有了自己的父类，就不可以继承Thread类，因为java单继承的局限性。

可是该类中的还有部分代码需要被多个线程同时执行。这时怎么办呢？

只有对该类进行额外的功能扩展，java就提供了一个接口Runnable。这个接口中定义了run方法，其实run方法的定义就是为了存储多线程要运行的代码。

所以，通常创建线程都用第二种方式。

因为实现Runnable接口可以避免单继承的局限性。

 

2：其实是将不同类中需要被多线程执行的代码进行抽取。将多线程要运行的代码的位置单独定义到接口中。为其他类进行功能扩展提供了前提。

所以Thread类在描述线程时，内部定义的run方法，也来自于Runnable接口。

 

实现Runnable接口可以避免单继承的局限性。而且，继承Thread，是可以对Thread类中的方法，进行子类复写的。但是不需要做这个复写动作的话，只为定义线程代码存放位置，实现Runnable接口更方便一些。所以Runnable接口将线程要执行的任务封装成了对象。

/* 
需求：简单的卖票程序。 
多个窗口卖票。 
*/  
class Ticket implements Runnable//extends Thread  
{  
    private  int tick = 100;  
    public void run()  
    {  
        while(true)  
        {  
            if(tick>0)  
            {  
                //显示线程名及余票数  
                System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);  
            }  
        }  
    }  
}  
  
  
class  TicketDemo  
{  
    public static void main(String[] args)   
    {  
        //创建Runnable接口子类的实例对象  
        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();  
    }  
}  

 

多线程安全问题的原因：

通过图解：发现一个线程在执行多条语句时，并运算同一个数据时，在执行过程中，其他线程参与进来，并操作了这个数据。导致到了错误数据的产生。

 

涉及到两个因素：

1，多个线程在操作共享数据。

2，有多条语句对共享数据进行运算。

原因：这多条语句，在某一个时刻被一个线程执行时，还没有执行完，就被其他线程执行了。

 

解决安全问题的原理：

只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行就可以解决这个问题。

 

如何进行多句操作共享数据代码的封装呢？

java中提供了一个解决方式：就是同步代码块。

格式：

synchronized(对象) {  // 任意对象都可以。这个对象就是锁。

需要被同步的代码；

}

同步：★★★★★

好处：解决了线程安全问题。

弊端：相对降低性能，因为判断锁需要消耗资源，产生了死锁。

 

定义同步是有前提的：

1，必须要有两个或者两个以上的线程，才需要同步。

2，多个线程必须保证使用的是同一个锁。

 

同步的第二种表现形式：

同步函数：其实就是将同步关键字定义在函数上，让函数具备了同步性。

 

同步函数是用的哪个锁呢？

通过验证，函数都有自己所属的对象this，所以同步函数所使用的锁就是this锁。

 

当同步函数被static修饰时，这时的同步用的是哪个锁呢？

静态函数在加载时所属于类，这时有可能还没有该类产生的对象，但是该类的字节码文件加载进内存就已经被封装成了对象，这个对象就是该类的字节码文件对象。

所以静态加载时，只有一个对象存在，那么静态同步函数就使用的这个对象。

这个对象就是 类名.class

 

同步代码块和同步函数的区别？

同步代码块使用的锁可以是任意对象。

同步函数使用的锁是this，静态同步函数的锁是该类的字节码文件对象。

 

在一个类中只有一个同步，可以使用同步函数。如果有多同步，必须使用同步代码块，来确定不同的锁。所以同步代码块相对灵活一些。

练习1：

package pack;
// 通过分析，发现：打印出0，-1，-2等错票。
// 多线程的运行出现了安全问题。
// 问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，
//		还没有执行完。另一个线程参与进来执行，导致共享数据的错误。
// 解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与。
// java对于多线程的安全问题提供了专业的解决方式。
// 就是同步代码块：synchronized(对象){需要被同步的代码}
//	对象如同锁，持有锁的线程可以再同步中执行，
//	没有持有锁的线程即使获取了CPU的执行权，也进不去，因为没有获取锁。
// 火车上的卫生间---经典。
// 同步的前提：1，必须要有两个或者以上的线程。2，必须是多个线程使用同一个锁。
// 必须保证同步中只能有一个线程在运行。
// 好处：解决了多线程的安全问题。
// 弊端：多个线程都需要判断锁，比较消耗资源。
class Ticket implements Runnable{
	private int tick=100;
	Object obj=new Object();
	public void run(){
		while(true){
			synchronized(obj){
				if(tick>0){
					System.out.println(Thread.currentThread().getName()+" :"+tick--);
				}
				else
					return ;
			}
		}
	}
}
class TicketDemo2{
	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();
	}
}

练习2：

package pack;
// 需求：银行有一个金库，
// 有两个储户分别寸300元，每次存100，存3次。
// 目的：该程序是否有安全问题，如果有，如何解决？
// 如何找问题：
//	1，明确哪些代码是多线程运行代码。
//	2，明确共享数据。
//	3，明确多线程运行代码中哪些语句是操作共享数据的。
class Bank{
	private int num;
	public synchronized void add(int a){
		num=num+a;
		System.out.println("num="+num);
	}
}
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 Single{
	private static Single s = null;
	private Single(){}
	public static Single getInstance(){ //锁是谁？字节码文件对象；
		if(s == null){
			synchronized(Single.class){
				if(s == null)
					s = new Single();
			}
		}
		return s;
	}
}

---------------------------------------------------------

同步死锁：通常只要将同步进行嵌套，就可以看到现象。同步函数中有同步代码块，同步代码块中还有同步函数。

/* 
写一个死锁程序 
*/  
  
//定义一个类来实现Runnable，并复写run方法  
class LockTest implements Runnable  
{  
    private boolean flag;  
    LockTest(boolean flag)  
    {  
        this.flag=flag;  
    }  
    public void run()  
    {  
        if(flag)  
        {  
            while(true)  
            {  
                synchronized(LockClass.locka)//a锁  
                {  
                    System.out.println(Thread.currentThread().getName()+"------if_locka");  
  
                    synchronized(LockClass.lockb)//b锁  
                    {  
                    System.out.println(Thread.currentThread().getName()+"------if_lockb");  
                    }  
                }  
            }  
        }  
        else  
        {  
            while(true)  
            {  
                synchronized(LockClass.lockb)//b锁  
                {  
                  System.out.println(Thread.currentThread().getName()+"------else_lockb");  
  
                    synchronized(LockClass.locka)//a锁  
                    {  
                   System.out.println(Thread.currentThread().getName()+"------else_locka");  
                    }  
                }  
            }  
        }  
    }  
}  
  
//定义两个锁  
class LockClass  
{  
    static Object locka = new Object();  
    static Object lockb = new Object();  
}  
  
class DeadLock  
{  
    public static void main(String[] args)  
    {  
        //创建2个进程，并启动  
        new Thread(new LockTest(true)).start();  
        new Thread(new LockTest(false)).start();  
    }  
}  

 

线程间通信：思路：多个线程在操作同一个资源，但是操作的动作却不一样。

1：将资源封装成对象。

2：将线程执行的任务(任务其实就是run方法。)也封装成对象。

 

等待唤醒机制：涉及的方法：

wait:将同步中的线程处于冻结状态。释放了执行权，释放了资格。同时将线程对象存储到线程池中。

notify：唤醒线程池中某一个等待线程。

notifyAll:唤醒的是线程池中的所有线程。

 

注意：

1：这些方法都需要定义在同步中。 

2：因为这些方法必须要标示所属的锁。

你要知道 A锁上的线程被wait了,那这个线程就相当于处于A锁的线程池中，只能A锁的notify唤醒。

3：这三个方法都定义在Object类中。为什么操作线程的方法定义在Object类中？

因为这三个方法都需要定义同步内，并标示所属的同步锁，既然被锁调用，而锁又可以是任意对象，那么能被任意对象调用的方法一定定义在Object类中。

 

wait和sleep区别： 分析这两个方法：从执行权和锁上来分析：

wait：可以指定时间也可以不指定时间。不指定时间，只能由对应的notify或者notifyAll来唤醒。

sleep：必须指定时间，时间到自动从冻结状态转成运行状态(临时阻塞状态)。

wait：线程会释放执行权，而且线程会释放锁。

Sleep：线程会释放执行权，但不是不释放锁。

 

线程的停止：通过stop方法就可以停止线程。但是这个方式过时了。

停止线程：原理就是：让线程运行的代码结束，也就是结束run方法。

怎么结束run方法？一般run方法里肯定定义循环。所以只要结束循环即可。

第一种方式：定义循环的结束标记。

第二种方式：如果线程处于了冻结状态，是不可能读到标记的，这时就需要通过Thread类中的interrupt方法，将其冻结状态强制清除。让线程恢复具备执行资格的状态，让线程可以读到标记，并结束。

 

java.lang.Thread 

interrupt()：中断线程。

setPriority(int newPriority)：更改线程的优先级。

getPriority()：返回线程的优先级。

toString()：返回该线程的字符串表示形式，包括线程名称、优先级和线程组。

Thread.yield()：暂停当前正在执行的线程对象，并执行其他线程。

setDaemon(true)：将该线程标记为守护线程或用户线程。将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。

join：临时加入一个线程的时候可以使用join方法。

当A线程执行到了B线程的join方式。A线程处于冻结状态，释放了执行权，B开始执行。A什么时候执行呢？只有当B线程运行结束后，A才从冻结状态恢复运行状态执行。

Lock接口：（多线程在JDK1.5版本升级）

解决线程安全问题使用同步的形式，(同步代码块，要么同步函数)其实最终使用的都是锁机制。

 

到了后期版本，直接将锁封装成了对象。线程进入同步就是具备了锁，执行完，离开同步，就是释放了锁。

在后期对锁的分析过程中，发现，获取锁，或者释放锁的动作应该是锁这个事物更清楚。所以将这些动作定义在了锁当中，并把锁定义成对象。

 

所以同步是隐示的锁操作，而Lock对象是显示的锁操作，它的出现就替代了同步。

 

在之前的版本中使用Object类中wait、notify、notifyAll的方式来完成的。那是因为同步中的锁是任意对象，所以操作锁的等待唤醒的方法都定义在Object类中。

 

而现在锁是指定对象Lock。所以查找等待唤醒机制方式需要通过Lock接口来完成。而Lock接口中并没有直接操作等待唤醒的方法，而是将这些方式又单独封装到了一个对象中。这个对象就是Condition，将Object中的三个方法进行单独的封装。并提供了功能一致的方法 await()、signal()、signalAll()体现新版本对象的好处。

包< java.util.concurrent.locks >     Condition接口：await()、signal()、signalAll()；

package pack;
// JDK1.5中提供了多线程升级解决方案，
// 将同步Synchronized替换成显示Lock操作。
// 将Object中的wait，notify，notifyall。替换成了Condition对象。
// 该对象可以Lock锁，进行获取
// 在该事例中，实现了本方只唤醒对方操作。
// 生产者与消费者有什么替代方案？
// 	1.5JDK提供了显示的锁机制，以及显示的锁对象中的等待唤醒操作机制。
// 	把锁进行封装，这样一个锁就可以对应多个Condition操作。
import java.util.concurrent.locks.*;
class Resource{
	private String name;
	private int tick=0;
	private boolean flag;
	private Lock lock=new ReentrantLock();
	private Condition pro=lock.newCondition();
	private Condition con=lock.newCondition();
	public void set(String name)throws InterruptedException{
		lock.lock();
		try{
			while(flag)
				pro.await();
			this.name=name+"-->"+tick++;
			System.out.println(Thread.currentThread().getName()+"生产者: "+this.name);
			flag=true;
			con.signal();
		}
		finally{
			lock.unlock();
		}
	}
	public void out()throws InterruptedException{
		lock.lock();
		try{
			while(!flag)
				con.await();
			System.out.println(Thread.currentThread().getName()+"消费者: "+this.name);
			flag=false;
			pro.signal();
		}
		finally{
			lock.unlock();
		}
	}
}
class Producer implements Runnable{
	private Resource res;
	Producer(Resource res){
		this.res=res;
	}
	public void run(){
		while(true){
			try{
				res.set(" 商品 ");
			}
			catch(InterruptedException e){}
		}
	}
}
class Consumer implements Runnable{
	private Resource res;
	Consumer(Resource res){
		this.res=res;
	}
	public void run(){
		while(true){
			try{
				res.out();
			}
			catch(InterruptedException e){}
		}
	}
}
class ProducerConsumerDemo2{
	public static void main(String[] args){
		Resource r=new Resource();
		new Thread(new Producer(r)).start();
		new Thread(new Consumer(r)).start();
	}
}

扩展小知识：

1、join方法

        当A线程执行到了b线程的.join（）方法时，A线程就会等待，等B线程都执行完，A线程才会执行。（此时B和其他线程交替运行。）join可以用来临时加入线程执行。

2、setPriority（）方法用来设置优先级

        MAX_PRIORITY 最高优先级10

        MIN_PRIORITY   最低优先级1

        NORM_PRIORITY 分配给线程的默认优先级

3、yield（）方法可以暂停当前线程，让其他线程执行。