理解面向对象编程（三）-线程、死锁

* 1.线程和进程的区别

    线程是程序中的不同执行路径

    java.lang.Thread

    方法：继承Thread或者实现Runnable接口，

    线程启动：Thread的start()方法

    调用该Runnable 对象的 run 方法和调用Thread的start方法本质区别:

    newThread(new Runner1()).start();

    newRunner1().run();

    start方法是启动线程，和main方法是并行运行

    runnable的run()是main执行到此，停下来，等run方法执行完再接着执行

    因此有本质的区别

    例子：

 

   publicclass test2 {
   
       publicstatic void main(String[] args) {
           //实现Runnable接口，推荐
           //newThread(new Runner1()).start();
           //newRunner1().run();
           //继承Thread类
           //newRunner1().start();
           for(inti=0;i<100;i++){
              System.out.println("Thread"+i);
           }
       }
    }
    //classRunner1 implements Runnable{//实现Runnable接口
    classRunner1 extends Thread{//继承Thread类
       @Override
       publicvoid run() {
           for(inti=0;i<100;i++){
              System.out.println("Runner"+i);
           }
       }
    } 

 *2.sleep方法/join方法/yield方法

    Thread.sleep()

    join相当于方法调用，等着子线程执行完，main才开始

    yield，让出cpu,给其他线程执行机会

 * 3.线程的优先级

    setPriority(Thread.MAX_PRIORITY)

 * 4.线程同步

    经典的例子：

  

  public class Test4 implements Runnable{
       Timertimer=new Timer();
       publicstatic void main(String[] args) {
           Test4test=new Test4();
           Threadt1=new Thread(test);
           Threadt2=new Thread(test);
           t1.setName("t1");
           t2.setName("t2");
           t1.start();
           t2.start();
       }
       @Override
       publicvoid run() {
           timer.add(Thread.currentThread().getName());
       }
    }
   
    classTimer{
       privatestatic intnum=0;
       //publicvoid add(String name){
       publicsynchronized void add(String name){//锁定当前对象
           num++;
           try{
              Thread.sleep(1);
           }catch(InterruptedExceptione){}
           System.out.println(name+"Thisis"+num+"Thread with timer");
       }
    }

 * 5.死锁例子

    

public class Test5  implements Runnable{
       privateintflag=1;
       staticObject o1=new Object();
       staticObject o2=new Object();
       publicstatic void main(String[] args) {
           Test5test1=new Test5();
           test1.flag=1;
           Test5test2=new Test5();
           test1.flag=0;    
           Threadt1=new Thread(test1);
           Threadt2=new Thread(test2);
           t1.start();
           t2.start();
       }
   
       @Override
       publicvoid run() {
           if(flag==1){
              synchronized(o1) {
                  try{
                     Thread.sleep(1000);
                  }catch(InterruptedExceptione){}
              }
              synchronized(o2) {
                  System.out.println("1");
              }
           }
           if(flag==0){
              synchronized(o2) {
                  try{
                     Thread.sleep(1000);
                  }catch(InterruptedExceptione){}
              }
              synchronized(o1) {
                  System.out.println("1");
              }
           }
          
       }
   
    }

   

 * 6.加了synchronized的方法可以访问其他没有加锁的线程，但是其他线程访问不了这个加了synchronized的方法

* 7.停掉一个线程，用new Thread().join()//关键

8.sleep和wait区别

sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。

而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备