Thread Runnable 多线程

1.         实现多线程的两种方法

a)         让这个类继承java.lang.Thread，然后重写run方法

b)         让这个类实现 java.lang.Runnable接口，实现run方法

2.         run()：Runnable接口中的run，如果该线程是使用独立的Runnable运行构造的，则调用该Runnable对象的run方法。如果这个类是一个线程类，只要启动线程，就会执行run()方法。

3.         start()：启动该线程，使该线程开始执行，Java虚拟机调用该线程的run()方法，多次启动一个线程是不允许的，特别是当该线程已经结束后，就不能再重新启动

4.         sleep(long millis)：使该线程睡眠（暂停执行）millis毫秒，此时，该线程不会丢失任何监听器所属权。

5.         yield ：暂停当前正在执行的线程，让其他线程执行。

6.         join(long millis)：等待该线程终止的时长为millis毫秒，超时为0意味着要一直等下去。就是在当前线程执行的时候再过millis毫秒，才能执行别的线程，合同线程。

7.         interrupt()：中断当前线程

8.         setPriority(long new Priority)：设置线程的优先级。Thread.NORM_PRIORITY，Thread.MAX_PRIORITY，Thread.MIN_PRIORITY

9.         synchronized：锁住当前执行的对象，该线程未结束前，被锁住的对象不允许被修改

10.     DeadLock：死锁

/**

 * 模拟死锁（线程同步问题）

 * @author Mr XP.Wang

 *

 */

public class TestDeadLock implements Runnable {

   

    private int flag = 0;

   

    static Object o1 = new Object(), o2 = new Object();

   

    @Override

    public void run() {

       System.out.println("flag="+flag);

       if (flag==1) {

           synchronized(o1){

              try {

                  Thread.sleep(500);

              } catch (InterruptedException e) {

                  e.printStackTrace();

              }

              synchronized(o2){//绝对不能执行，因为必须等待o1执行完毕，o1永远不能执行完毕，所以死锁

                  System.out.println("1");

              }

           }

       }

       if (flag==0) {

           synchronized(o2){

              try{

                  Thread.sleep(500);

              } catch(InterruptedException e) {

                  e.printStackTrace();

              }

              synchronized(o1){

                  System.out.println("0");

              }

           }

       }

    }

 

    public static void main(String[] args) {

       TestDeadLock td1 = new TestDeadLock();

       TestDeadLock td2 = new TestDeadLock();

       td1.flag=1;

       td2.flag=0;

       Thread t1 = new Thread(td1);

       Thread t2 = new Thread(td2);

       t1.start();

       t2.start();

    }

 

}

 

11.     线程是一个程序内部的程序控制流

12.     线程和进程的区别

a)         每个进程都有独立的代码和数据空间（进程上下文），进程之间的切换需要较大的开销

b)         进程可以看成是轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程的切换开销小

c)         多进程：在操作系统中能同时运行多个任务（程序）

d)         多线程：在同一个应用程序中有多个顺序流同时执行

13.     Java的线程是通过java.lang.Thread类来实现的

14.     VM启动时会有一个由主方法（public static void main(String[] args）所定义的线程。

15.     可以通过创建Thread的实例来创建新的线程

16.     每个线程都是通过特定Thread对象所对应的方法run()来完成操作的，方法run()称为线程体

17.     通过调用Thread类的start()方法来启动一个线程

线程控制的基本方法

isAlive()

判断线程是否还“活着”，即线程是否为终止

getPriority()

获得线程的优先级数值

setPriority()

设置线程的优先级数值

Thread.sleep()

将当前线程睡眠，指定毫秒数

join()

调用某线程的该方法，将当前线程与该线程“合并”，即等待该线程结束，再恢复当前线程的运行

yield()

让出CPU，让其他线程进入就绪队列等待调度（慢一点再执行）

wait()

当前线程进入对象的wait pool.

notiry()/

notifyAll

唤醒对象的wati pool中的一个/所有线程

18. 

     

Ø  Java提供一个线程调度器来控制监听程序中启动后进入就绪状态的所有线程。线程调度器按照线程的优先级决定调度哪个线程来执行

Ø  线程的优先级用数字来表示，范围从1到10，一个线程的缺省优先级为5

1.   Thread.MIN_PRIORITY=1

2.   Thread.MAX_PRIORITY=10

3.   Thread.NORM_PRIORITY=5

Ø  使用下列方法获得或设置线程的优先级

1.   getPriority()

2.         void setPriority(int newPriority)

 

 

 

 

 

 

 

 

 

 

 

 

19. 在Java语言中，引入了对象互斥锁的概念，保证共享数据操作的完整性。每个对象都对应一个互称为“互斥锁”的标记，这个标记保证在任意时刻，只有一个线程访问该对象

20. 关键之synchronized来与对象的互斥锁联系。当某个对象synchronized修饰时，表示该对象在任意一个时候只能由一个线程访问
synchronized(this){
    //Java Code
}

21. Synchronized还可以放在方法声明中，表示整个方法为声明方法，例如：
synchronized public void add(String name){//……}

 

 

Ø  Wait 与 sleep区别

Ø  Wait时，别的线程可以访问锁定对象

Ø  Sleep时，别的线程不可以访问该对象

22.