多线程之基础

96
vaneL
2017.08.03 15:58* 字数 1337

进程和线程:
● 进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1~n个线程。
● 线程:同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换开销小。

线程五状态.png

线程和进程一样分为五个阶段:

1.新建状态(New):新创建了一个线程对象。
2.就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中,变得可运行,等待获取CPU的使用权。
3.运行状态(Running):就绪状态的线程获取了CPU,执行程序代码。
4.阻塞状态(Blocked):阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。
阻塞的情况分三种:
● 等待阻塞:运行的线程执行wait()方法,JVM会把该线程放入等待池中。
● 同步阻塞:运行的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则JVM会把该线程放入锁池中。
● 其他阻塞:运行的线程执行sleep()或join()方法,或者发出了I/O请求时,JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。
5.死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。

并行和并发:
● 并行:多个cpu实例或者多台机器同时执行一段处理逻辑,是真正的同时
● 并发:多个CPU实例或者多台机器在同一时间间隔发生。

创建任务的线程:

第一种是创建Thread子类的一个实例并重写run方法,不适合资源共享。
第二种是创建类的时候实现Runnable接口,则很容易的实现资源共享。
注意:start()方法的调用后并不是立即执行多线程代码,而是使得该线程变为可运行态(Runnable),什么时候运行是由操作系统决定的。

//创建一个线程
Tread thread = new Thread();
thread.start();

//创建Thread子类的一个实例并重写run方法,run方法会在调用start()方法之后被执行。
public class MyThread extends Thread {
   public void run(){
     System.out.println("MyThread running");
   }
}

MyThread myThread = new MyThread();
myTread.start();

//创建一个Thread的匿名子类
Thread thread = new Thread(){
   public void run(){
     System.out.println("Thread Running");
   }
};
thread.start();
//新建一个实现了java.lang.Runnable接口的类的实例
public class MyRunnable implements Runnable {
   public void run(){
    System.out.println("MyRunnable running");
   }
}

Thread thread = new Thread(new MyRunnable());
thread.start();

//创建一个实现了Runnable接口的匿名类
Runnable myRunnable = new Runnable(){
   public void run(){
     System.out.println("Runnable running");
   }
}
Thread thread = new Thread(myRunnable);
thread.start();

如果同时重写Thread类和Runnable接口的run方法,上面执行的run方法到底是Runnable的还是Thread的呢?

public class ThreadTests {  
  
    public static void main(String[] args) {  
        new Thread(new Runnable(){  
            public void run() {  
                System.out.println("Thread Runing in Runnable...");  
            }  
        }){  
            public void run() {  
                System.out.println("Thread Runing in Parent Thread...");  
            }  
        }.start();  
    }  
}  

结果:Thread Runing in Parent Thread...
总结:查看Thread类的run()方法的源代码,可以看到其实这两种方式都是在调用Thread对象的run()方法,如果Thread类的run方法没有被覆盖,并且为该Thread对象设置了一个Runnable对象,该run方法会调用Runnable对象的run方法。即是先运行的Thread对象的run方法,如果Thread对象重写run方法,就去运行Thread的run方法。

提醒:main方法其实也是一个线程。在java中所以的线程都是同时启动的,至于什么时候,哪个先执行,完全看谁先得到CPU的资源。
在java中,每次程序运行至少启动2个线程。一个是main线程,一个是垃圾收集线程。因为每当使用java命令执行一个类的时候,实际上都会启动一个JVM,每一个JVM实习在就是在操作系统中启动了一个进程。

public class Thread implements Runnable{

   /*暂停当前正在执行的线程对象,并执行其他线程。*/
   public static native void yield();
   /*将线程设置为休眠以确保其他线程执行,休息时间为毫秒。*/
   public static native void sleep(long millis) throws InterruptedException; 
   /*使一个线程等待另一个线程的结束*/
   public final void join() throws InterruptedException {
       join(0);
   }

   @Override
   public void run() {
       if (target != null) {
           target.run();
       }
   }
}

● sleep()和yield()的区别:
sleep()使当前线程进入停滞状态,所以执行sleep()的线程在指定的时间内肯定不会被执行;
yield()只是使当前线程重新回到可执行状态,所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
sleep方法允许较低优先级的线程获得运行机会
但 yield()方法执行时,当前线程仍处在可运行状态,所以,不可能让出较低优先级的线程些时获得 CPU 占有权。
● sleep()和wait()方法的最大区别是:
sleep()睡眠时,保持对象锁,仍然占有该锁;而wait()睡眠时,释放对象锁。

  • 线程等待:
    Object类中的wait()方法,导致当前的线程等待,直到其他线程调用此对象的 notify() 方法或 notifyAll() 唤醒方法。
    Obj.wait(),与Obj.notify()必须要与synchronized(Obj)一起使用

  • 线程唤醒:Object类中的notify()方法,唤醒在此对象监视器上等待的单个线程。
    如果所有线程都在此对象上等待,则会选择唤醒其中一个线程。
    选择是任意性的,并在对实现做出决定时发生。线程通过调用其中一个 wait 方法,在对象的监视器上等待。

学习笔记