黑马程序员_多线程通信

---------- android培训、java培训、期待与您交流！ ----------

1.包(package)：包名具有唯一性。

在windows中的具体体现：文件夹。
1.包的作用：1.分类管理类文件；
2.对类提供了多层名称空间。
2.如何定义：使用关键字 package,定义必须定义在源代码的第一行，类名的全称是：包名.类名；
包名全小写如mypackage.
3.步骤：1.javac -d 包的路径 全类名.java
2.set classpath=包的路径；

3.java 包名.类名

一个包中不能存在两个public修饰的类。
被访问的包中，类和方法都需要被public修饰，否则权限不够。

4.包与包之间的继承
protected:包的修饰符，保护权限，只有子类才能用；用于保护父类中的成员。
protected 保护子类使用：必须子类才可以用，非子类则不可以用。

四种权限：  public protected   default(默认的)private
同一个类中：  ok    ok      ok   ok
同一个包中：  ok            ok            ok 
子类：      ok            ok
不同包中：      ok
    
5.简化书写：使用import关键字导入，格式：import 全类名；导入的都是包中的类；若是需要导入多个类，则使用通配符，如 import packa.*。
而在真实开发时，用到哪个则导入哪个，根本也用不到导入，用高级编辑器。
6.注意：
1.import packa.* ：只导入packa包的当前目录下的所有类，而不导入当前目录下的包。
2.当导入的包中的类有重名时，使用该类时，必须用包名.类名的全名称，否则无法区分，会产生使用的不确定性。
  如 import packa.Demo;
     import packb.Demo;

不能new Demo(),而需new packa.Demo();

2.Jar包：java的压缩包。
-c:创建新的归档文件
-x:解压
java压缩工具：jar cvf haha.jar pack
jar包的基本使用。只要将类和包都存储到jar中，方便于使用。只要将jar配置到classpath路径下。 
  压缩：jar cf 归档名.jar 包名
  解压：jar -xvf 归档名.jar

3.多线程技术
1.进程：正在进行中的程序。
2.线程(Thread)：负责进程进行执行。一个进程至少有一个线程，若有多个则称为多线程程序；线程也可以称为执行线程、执行路径、执行背景。
3.好处：可以同时执行多个程序。
4.JVM多线程的基本体现：
JVM也是多线程，至少有一个主线程和垃圾回收线程。主线程执行的是主函数中的内容，垃圾回收线程执行的对堆内存进行内存释放的代码。
5.垃圾回收的方法：finalize(),垃圾回收
 gc()：运行垃圾回收器,System.gc();启动后不一定立即执行，因为CPU在随机做着切换，先切换到哪就先执行哪个。
6.自定义线程：
    通过API Thread类的查阅，两种方式：
1.继承Thread类，覆写run()方法，创建Thread子类对象，调用start方法来开启线程并调用run方法；线程类在描述线程时，有一个功能函数run，专门  用于封装执行的任务。
 主线程也是同理，该线程执行的任务在主函数中。
     
2.定义一个实现Runnable接口的类，然后该类实现 run 方法。然后可以分配该类的实例，在创建线程时作为一个参数来传递并启动。
1.定义类实现Runnable接口;
  2.覆写该接口中的run()方法；
  3.通过Thread类创建线程对象；
  4.将实现Runnable接口的实现类的对象作为参数传递给Thread类的构造函数，将run方法所属的对象传递给线程，让线程去执行我们指定的代码任务；
  5.调用start方法，目的是开启线程并调用run方法。
     
  Thread t=new Thread();创建进程。
1.覆写run方法的原因：创建进程的目的是为了运行指定的代码，任务就应该自己指定。

2.特定方法start():开启线程并调用run方法运行线程。
start和run区别：调用run方法，并没有开启新的线程，都是由主线程来执行，无法完成同时运行的需求；
       调用start方法，开启了新的线程并调用了线程的任务方法run方法，实现了代码同时执行。

3.执行路径是在每一条路径上先进后出的，即每个线程都有自己单独的一片栈内存空间。
4.currentThread():返回当前正在执行的进程，Thread.currentThread().getName();结果是Thread-编号，编号从0开始。

5.线程是分区来进行管理的，当前线程发生异常只影响当前线程，不影响其它线程。
6.主线程是最后结束的线程，只要还有存活的线程，它就不能结束。
7.创建线程的目的：为了开辟一个执行路径去执行指定的代码，让其和其它代码同时运行；意味着每一个线程的创建都有自己要运行的内容，而这个内容也称为线程的任务。

7.线程的随机性的导致的原因？
一个CPU在处理多个线程时，进行着随机的快速切换，切换到哪个线程就执行哪个线程，从而出现了随机性。

8.什么时候使用多线程？以及创建线程的目的？
     目的：为了开辟一个执行路径去执行指定的代码，让其和其它代码同时运行；意味着每一个线程的创建都有自己要运行的内容，而这个内容也称为线程的任务。

     使用：为了让多个执行路径同时进行，各自运行各自的内容，就可以使用多进程。

4.线程的四种状态：被创建、运行、冻结notify、sleep、wait、消亡(还有一个特殊状态：就绪)

每一个状态的特点？
  被创建：调用start()方法,开启线程并调用run()方法；
  运行：该状态是持有执行资格和CPU的执行权；
  冻结：既不具备CPU的执行权，也不具备执行资格；运行状态时调用了sleep()方法，当时间到了才转回运行状态；
  消亡：运行状态的run方法执行完成或者调用stop()方法；释放内存。

5.了解

6·Runnable接口出现的好处
  1.避免了单继承的局限性(线程对象和线程任务的耦合性很强);
  2.按照面向对象的思想，将线程运行的任务进行单独的对象封装，降低了线程对象和线程任务的耦合性。
 
  即：继承Thread类时，子类对象是一个线程对象；而在实现Runnable接口时，子类对象是一个线程任务，创建新的线程对象，
  将要执行的线程任务作为参数传递给线程对象，通过Thread类的构造函数将线程对象和线程任务关联起来。

class Demo implements Runnable{//将线程要运行的任务代码封装到了该run方法中。 public void run(){for(int x=1; x<=20; x++){System.out.println(Thread.currentThread().getName()+"......"+x);}}}class ThreadDemo4{public static void main(String[] args) {Demo d = new Demo();//创建线程对象。因为没有了Thread的子类。所以通过Thread类来完成线程对象的创建。Thread t1 = new Thread(d);Thread t2 = new Thread(d);t1.start();//开启了线程并调用了线程中的run方法。只不过线程类中的run方法并没有定义我们要让线程运行的内容。 t2.start();

7·四个窗口售票的案例

 class Ticket implements Runnable { private int num = 100; //为了给同步代码块指定一个对象。可以用自定义的，也可以用已有的。 比如Object private Object obj = new Object(); public void run() { while(true) { synchronized(obj)//这个对象就相当于一个锁。 { if(num>0) { try{Thread.sleep(10);}catch(InterruptedException e){}//让当前线程在这里小睡一下。 System.out.println(Thread.currentThread().getName()+"......"+num--); } } } } } 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); Thread t4 = new Thread(t); t1.start(); t2.start(); t3.start(); t4.start(); } }

内存图分析：


8·线程的安全问题

产生原因分析：1.多个线程在处理同一共享数据；
  2.线程任务代码中有多条语句在操作这个共享数据，这些多条操作共享数据的语句被线程分开进行执行，在一个线程执行这些语句的过程中，其它线程参与了运算导致数据的错误。

  线程任务中只要存在着：共享数据、多条操作共享数据的语句，就会产生安全问题。

9·安全问题的解决
  解决思想：对多条操作共享数据的语句，只能让一个线程都执行完，执行过程中，其它线程不可参与执行；
  将多条操作共享数据的语句进行封装，只有一个线程在内执行，运行期间其它进程进不来，只有这个线程执行完，其它线程才有执行的机会。
  方式：通过synchronized(对象){需要同步的代码；}需要同步的代码包括所有操作共享数据的代码，对象可以自定义，也可以是已有的，对象出来后再释放给
  同步代码块。

10·同步的好处：解决了多线程的安全问题；
  弊端：降低了效率，同一时刻只能有一个线程运行；而且易出现死锁。
  前提：必须是多个线程，使用的是同一个锁对象。

11·同步函数：在函数上加入同步关键字synchronized；
  同步函数和同步代码块的区别：
  1.同步函数在写法上较简洁；
  2.同步函数的锁对象是固定的，而同步代码块的锁对象是任意的，建议用同步代码块，尤其是在代码中使用多个同步不同锁时，必使用同步代码块。

同步函数，和静态同步函数使用的锁是：
   同步函数：对象.getClass();
   静态：类名.class

12·懒汉式：当多线程并发访问时，会出现多线程的安全问题，无法保证对象的唯一性，这时用同步函数来解决这个问题，但同时产生新的问题：降低性能。
  解决性能降低的方法：通过双重判断的格式，写同步代码块且在代码块前加if判断语句，好处是：减少判断锁的动作，相对提高了性能。

 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;}}class Test{public static void main(String[] args) {System.out.println("Hello World!");}}

13·死锁：
  常见情况之一：同步的嵌套，即同步中还有同步，而锁对象不同。
  一个运行在flag为true的同步代码块中，另一个运行在flag为false的同步函数中，让同步函数中有同步代码块，同步代码块中有同步函数。

class Test implements Runnable{private static final Object lock1=new Object();private static final Object lock2=new Object();private boolean flag;Test(boolean flag){this.flag=flag;}public void run(){if (flag){while (true){synchronized(lock1){System.out.println("if ....lock1 ");synchronized (lock2){System.out.println("if ....lock2");}}}}else {while (true){synchronized(lock2){System.out.println("else ....lock2 ");synchronized (lock1){System.out.println("else ....lock1");}}}}}}class DeadLockTest {public static void main(String[] args) {Test t1=new Test(true);Test t2=new Test(false);Thread ta=new Thread(t1);Thread tb=new Thread(t2);ta.start();tb.start();}}

14·线程间通信：有多个线程在处理同一个资源，但是处理的动作却不一样。(一进一出)
  示例：资源中有姓名和性别，一个线程负责赋值，一个线程负责取值。
  //创建资源对象；
  //创建线程任务对象；
  //创建线程对象；
  //开启线程。
  分析：input：在资源中定义标记用于判断资源是否有值，boolean flag=false;当标记为true，说明有值，input应该等待，让output运行。
   output：当资源中标记为false，说明没值，output执行输出，输出完改标志flag=true,


16·多线程间通信最为重要的机制：等待唤醒机制。涉及方法：wait(),notify(),notifyAll().
 
  wait():可以让线程处于冻结状态，释放执行资格和执行权。同时将线程存储到一个线程池中，wait前先释放锁。
  notify():只唤醒线程池中的一个线程，随机任意的。

  nitifyAll():唤醒线程池中的所有线程，让所有线程都具备执行资格。

  

  这些方法就是用在锁上的，都必须使用在同步中，因为同步中带有锁，同步可以有多个，但只有一个同步锁，用同步锁来区分。
  所以在使用时，必须要明确wait的是哪个锁上的线程，notify的是哪个锁上的线程，调用时用锁对象来调用。
 
  为什么这些方法定义在Object中？这些方法都用在同步中，而同步锁是任意对象，任意对象都能用的方法应该定义在Object类中。

17·生产者消费者案例
    多生产者和多消费者：
问题：发生数据的错乱。
原因：被唤醒的线程没有去判断标记，直接进行了执行。
解决：用while循环，当它被notify后，再去判断一下标记。
新问题：本方在唤醒过程中可能唤醒到本方线程，本来只需唤醒对方一个线程就可以了，导致效率过低。
解决：用新版本，将锁对象与监视器分离，一个锁对象绑定两组监视器，一组监视生产者，一组监视消费者。


18·多线程技术的升级：JDK1.5版本中提供了一个java.util.concurrent.locks.Lock接口，对锁进行单独的描述个封装，并定义操作的锁的方法在锁对象中。
  同步代码块和同步函数：对锁的操作是隐式的；
  Lock接口：显示操作锁。

  用Lock接口代替同步后，不能再有wait().notify().notifyAll()等方法。
  而提供了Condition接口，将操作锁上线程的状态方法（等待，唤醒，唤醒所有）进行了单独的封装，都封装到了Condition对象中。
  Condition改写：以前要解决，希望有两组监视器放分别监视不同的线程，一组监视生产者，一组监视消费。
  但是之前监视器方法和锁是绑定的，两组监视器需要两个锁，很有可能出现同步嵌套，很容易出现死锁.

  但改写后问题依旧存在，本方还是一样会唤醒全部(本方).
  解决方案：一个锁对象，绑定多组监视器。一组监视生产者，一组监视消费者。

  好处：以前是一个监视器方法上只能有一个锁，现在一个锁能有多个监视器方法。      

      import java.util.concurrent.locks.*;     class Res     {       private String name;       private int count = 1;       private boolean flag;       //创建一个显示锁对象。       private Lock lock = new ReentrantLock();       //获取到该lock锁上监视器对象。该监视器对象负责监视生产者。       private Condition producer_con = lock.newCondition();       private Condition consumer_con = lock.newCondition();              public  void set(String name)//        {       // 获取锁。显示方法        lock.lock();       try       {       while(flag)       try{producer_con.await();}catch(InterruptedException e ){}//t0(t2将其唤醒  wait) t1(被t0唤醒了 wait)              this.name = name+count;//商品-1  商品-2  商品-3              count++;//2 3 4       System.out.println(Thread.currentThread().getName()+"...生产者...."+this.name);//生产 商品-1  生产 商品-2 生产 商品-3       flag = true;       consumer_con.signal();       }finally{       //释放锁。       lock.unlock();       }       }       public  void out()//        {       lock.lock();       try       {       while(!flag)       try{consumer_con.await();}catch(InterruptedException e ){}//t2(wait) t3{wait)       System.out.println(Thread.currentThread().getName()+"........消费者......."+this.name);//消费 商品-1       flag = false;       producer_con.signal();       }       finally       {       lock.unlock();       }       }       }     class Producer implements Runnable     {       private Res r;       Producer(Res r)       {       this.r = r;       }       public void run()       {       while(true)       {       r.set("商品-");       }       }       }     class Consumer implements Runnable     {       private Res r;       Consumer(Res r)       {       this.r = r;       }       public void run()       {       while(true)       {       r.out();       }       }     }     class ProConDemo2      {       public static void main(String[] args)        {       Res r = new Res();       Producer pro = new Producer(r);       Consumer con = new Consumer(r);       Thread t0 = new Thread(pro);       Thread t1 = new Thread(pro);       Thread t2 = new Thread(con);       Thread t3 = new Thread(con);

       t0.start();       t1.start();       t2.start();       t3.start();       }     }

19·sleep和wait的区别：

  1.sleep:必须指定睡眠时间；
   wait：可以指定可以不指定，如果没指定，必须用notify唤醒。
  2.在同步中：
  sleep：释放执行权，但不释放锁对象，因为会自动醒；
  wait：释放执行权，还会释放锁。
  3.wait:必须用在同步中；
   sleep：可以不定义在同步中。

20. 停止线程  
方式：只要run方法结束，线程就停止，而run方法中通常有循环结构，所以只要控制住循环条件即可；
控制方式：定义一个boolean类型的变量flag来作为标记，定义一个功能来改变flag值。
特殊情况：当在while循环中加入wait方法，由于开启的线程都可能被wait，这样线程就不能结束。
解决方法：用interupt方法，可以将被wait的线程从冻结状态强制恢复到运行状态；
应用场景：用于sleep的时间还没到就需要结束线程，或者wait没有被notify,即强制唤醒，但因其强制，所以存在异常；
改进：将改标记的操作加入到catch块中，当interupt发生异常后，处理异常时，改标记flag=false；再回去读标记时，结束循环。

21.setDaemon方法：参数boolean型，将线程设为守护线程或者用户线程；
特点：具有依耐性，只要前台线程结束，后台线程自动结束。

toString():返回线程名称、线程优先级和线程组。
优先级：1-10；最小优先级1，默认优先级5，最大优先级10.如果都在抢CPU，则优先级一样；
线程组：可以统一操作一组线程。

setPriority：设置线程优先级，如setPriority(Thread.MAX_PRIORITY)。
join():临时加入一个线程进行执行，当主线程持有执行权执行到t1的join方法时，说明t1要加入运行，这是主线程会释放出执行权和执行资格，t1就开始执行，主线程不依赖时间和唤醒，当t1线程执行结束，主线程自动获得执行资格；但如果t1中有wait方法，则线程就不能结束。

yield():释放当前线程的执行权，让其他线程有机会具备执行权；

---------- android培训、java培训、期待与您交流！ ----------