Java笔记（二）

10.

	public	protected	default	private
同一个类中	√	√	√	√
同一个包中	√	√	√
子类	√	√
不同包中	√

11. 线程：

　static Thread currentThread()：获取当前线程对象

　getName()：获取线程名称

　设置线程名称：setName()或者构造函数

　创建线程的方式：

　　1. 继承Thread类

　　　　（1）定义类，继承Thread

　　　　（2）复写Thread类中的void run()方法（因为Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。）

　　　　（3）调用线程的start方法，该方法能启动线程，并能调用run方法

　　　　注：对象.run()仅仅是对象调用方法。而线程创建了，并没有运行；

　　　　　　对象.start()开启线程并执行该线程的run方法

　　2. 实现Runnable接口

　　　　（1）定义类，实现Runnable接口

　　　　（2）覆盖Runnable接口中的run方法。将线程要运行的代码存放在该run方法中

　　　　（3）通过Thread类建立线程对象

　　　　（4）将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。因为，自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去执行指定对象的run方法，就必须明确该run方法所属的对象。

　　　　（5）调用Thread类的start方法开启线程，并调用Runnable接口子类的run方法

　　实现方式与继承方式的区别：

　　　实现方式好处：避免了单继承的局限性。在定义线程时，建议使用实现方式。

　　　继承Thread：线程代码存放在Thread子类run方法中；实现Runnable：线程代码存放在接口的子类的run方法。

　同步函数的锁是this；静态同步函数的锁是Class对象（类名.class）

　死锁：例：

 class DeadLock implements Runnable{
     private boolean flag;
     DeadLock(boolean flag){
         this.flag = flag;
     }
     public void run(){
         if(flag){
             while(true){
                 synchronized(Lock.locka){
                     System.out.println("if locka");
                     synchronized(Lock.lockb){
                         System.out.println("if lockb");
                     }
                 }
             }
         }
         else{
             while(true){
                 synchronized(Lock.lockb){
                     System.out.println("else lockb");
                     synchronized(Lock.locka){
                         System.out.println("else locka");
                     }
                 }
             }
         }
     }
 }

 class Lock{
     public static Object locka = new Object();
     public static Object lockb = new Object();
 }

 public class Demo{
     public static void main(String[] args) {
         Thread t1 = new Thread(new DeadLock(true));
         Thread t2 = new Thread(new DeadLock(false));
         t1.start();
         t2.start();
     }
 }

　wait()  notify()  notifyAll():

　　都使用在同步中，因为要对持有监视器（锁）的线程操作，只有同步才具有锁。

　　这些方法在操作同步中线程时，都必须要标识它们所操作线程持有的锁。只有同一个锁上的被等待线程，可以被同一个锁上的notify()唤醒，不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。而锁可以是任意对象，所以可以被对象调用的方法定义Object类中。

　　生产者-消费者问题：

 class Resource{
     private String name;
     private int count = 1;
     private boolean flag = false;

     public synchronized void set(String name){
         while(flag){
             try {
                 this.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         this.name = name + " ~~ " + count++;
         System.out.println(Thread.currentThread().getName() + "..生产者.." + this.name);
         flag = true;
         this.notifyAll();
     }

     public synchronized void out(){
         while(!flag){
             try {
                 this.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         System.out.println(Thread.currentThread().getName() + "....消费者...." + this.name);
         flag = false;
         this.notifyAll();
     }
 }

 class Producer implements Runnable{
     private Resource r;
     Producer(Resource r){
         this.r = r;
     }
     public void run(){
         while(true){
             r.set("商品");
         }
     }
 }

 class Consumer implements Runnable{
     private Resource r;
     Consumer(Resource r){
         this.r = r;
     }
     public void run(){
         while(true){
             r.out();
         }
     }
 }

 public class Demo{
     public static void main(String[] args) {
         Resource r = new Resource();
         Thread t1 = new Thread(new Producer(r));
         Thread t2 = new Thread(new Producer(r));
         Thread t3 = new Thread(new Consumer(r));
         Thread t4 = new Thread(new Consumer(r));
         t1.start();
         t2.start();
         t3.start();
         t4.start();
     }
 }

　对于多个生产者和消费者。定义while判断标记的原因：让被唤醒的线程再一次判断标记。

　　　　　　　　　　　　　定义notifyAll的原因：需要唤醒对方线程。如果只用notify，容易                                        出现只唤醒本方线程的情况。导致程序中的所有线程都等待。

生产者-消费者（升级版）：

 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;

 class Resource{
     private String name;
     private int count = 1;
     private boolean flag = false;
     private Lock lock = new ReentrantLock();
     private Condition condition_pro = lock.newCondition();
     private Condition condition_con = lock.newCondition();

     public void set(String name) throws InterruptedException{
         lock.lock();
         try{
             while(flag){
                 condition_pro.await();
             }
             this.name = name + " ~~ " + count++;
             System.out.println(Thread.currentThread().getName() + "..生产者.." + this.name);
             flag = true;
             condition_con.signal();
         }finally{
             lock.unlock();
         }
     }

     public void out() throws InterruptedException{
         lock.lock();
         try{
             while(!flag){
                 condition_con.await();
             }
             System.out.println(Thread.currentThread().getName() + "....消费者...." + this.name);
             flag = false;
             condition_pro.signal();
         }finally{
             lock.unlock();
         }
     }
 }

 class Producer implements Runnable{
     private Resource r;
     Producer(Resource r){
         this.r = r;
     }
     public void run(){
         while(true){
             try {
                 r.set("商品");
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 }

 class Consumer implements Runnable{
     private Resource r;
     Consumer(Resource r){
         this.r = r;
     }
     public void run(){
         while(true){
             try {
                 r.out();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 }

 public class Demo{
     public static void main(String[] args) {
         Resource r = new Resource();
         Thread t1 = new Thread(new Producer(r));
         Thread t2 = new Thread(new Producer(r));
         Thread t3 = new Thread(new Consumer(r));
         Thread t4 = new Thread(new Consumer(r));
         t1.start();
         t2.start();
         t3.start();
         t4.start();
     }
 }

　JDK1.5中提供了多线程升级解决方案。将同步Synchronized替换成Lock操作。将Object中的wait、notify、notifyAll替换成了Condition对象，该对象可以Lock锁进行获取。

　如何停止线程：stop方法已经过时，只能让run方法结束。开启多线程运行，运行代码通常是循环结构。只要控制住循环，就可以让run方法结束，也就是线程结束。

　特殊情况：当线程处于冻结状态。就不会读取到标记，那么线程就不会结束。当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除。强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。

　Thread类提供该方法interrupt();

 class StopThread implements Runnable{
     private boolean flag = true;
     public synchronized void run(){
         while(flag){
             try{
                 wait();
             }catch(InterruptedException e){
                 System.out.println(Thread.currentThread().getName() + "...exception");
             }
             System.out.println(Thread.currentThread().getName() + "...run");
         }
     }
     public void changeFlag(){
         flag = false;
     }
 }

 public class Demo{
     public static void main(String[] args) {
         StopThread st = new StopThread();
         Thread t1 = new Thread(st);
         Thread t2 = new Thread(st);
         t1.start();
         t2.start();

         int num = 0;
         while(true){
             if(num++ == 60){
                 t1.interrupt();
                 t2.interrupt();
                 st.changeFlag();
                 break;
             }
             System.out.println(Thread.currentThread().getName() + "....." + num);
         }
         System.out.println("over");
     }
 }

输出结果：

...
...
main.....59
main.....60
over
Thread-0...exception
Thread-0...run
Thread-1...exception
Thread-1...run

　守护线程：即后台线程。线程对象.setDaemon(true)

　当正在运行的线程都是守护线程时（即前台线程全结束），JVM退出。该方法必须在启动线程前调用。

　Join方法：线程对象.join()，当A线程执行到了B线程的.join()方法，A就会等待。等B线程都执行完，A才会执行。join可以用来临时加入线程执行。

　yield方法：暂停当前正在执行的线程对象，并执行其他线程。