黑马程序员_多线程

一、多线程

       进程：正在运行的应用程序。

       线程：进程的的执行单元，一条执行路径。

       多线程：一个应用程序有多条执行路径。

二、创建多线程的方法

        总共有2钟方式：

    第一种：

        思路：1.定义一个类继承Thread

                  2.重写run方法:

                  3.线程启动并运行

      代码：

      public class MyThread extends Thread {//继承一个线程。
	@Override
   	public void run() {
		for (int x = 0; x < 100; x++) {
			System.out.println(getName()+"---hello" + x);
		}
	}
}

public class ThreadDemo {
	public static void main(String[] args) {
		MyThread my1 = new MyThread();
		MyThread my2 = new MyThread();

		my1.setName("用友");//设置名字
		my2.setName("金蝶");

	       my1.start();//启动线程并运行
		my2.start();
	}
}

   如果我们用对象去掉用run方法的话，它就是一个普通方法了，所有调用start方法有2个作用，第一个是启动线程，第二个是 调用run方法。

</pre><pre class="html" name="code">   第二种方法是取实现Runnable接口

    思路：1.定义一个类实现Runnable接口

         2.重写run方法

         3.创建类的实例

         4.把这个类的实例作为线程构造方法的参数传递，创建线程。

   代码：

    public class MyRunnable implements Runnable {

     @Override
     public void run() {//重写run方法
      for (int x = 0; x < 100; x++) {

      System.out.println(Thread.currentThread().getName() + "---hello"
     + x);
    }
  }

  }

   public class MyRunnableDemo {
     public static void main(String[] args) {
         MyRunnable my = new MyRunnable();
         Thread t1 = new Thread(my);
          Thread t2 = new Thread(my);

           t1.setName("乔峰");
           t2.setName("慕容复");

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

    有了Thread类了，为啥还要用接口Runnablene 呢？

   1.避免了类继承的局限性，

   2.通过实现接口只创建了一个对象，共享资源，使的数据和操作完全分离。

三、线程的生命周期

  共有创建，就绪，运行，阻塞，死亡。

四、多线程出现问题的判断条件

   1.看是否有共享数据

   2.看共享数据是否被多次操作

   3.看是否在多线程中

五、线程通信

    概念：不同的线程对共享数据操作的问题。

  同步关键字Synchronezed

   不同机制的锁对象

     1.同步代码块中的锁对象可以是任意对象，就是把关键字放在方法中

     2.同步方法的锁多象就是this  ，就是把关键字放在方法上

     3.静态方法的锁对象类名.class，就是把关键字放在申明上

六、线程的死锁问题

    代码：

   // 定义死锁对象

     public class MyLock {
          public static final Object objA = new Object();
          public static final Object objB = new Object();
     }

// 定义一个类继承Thread

     public class DieLock extends Thread {

       private boolean flag;

       public DieLock(boolean flag) {
      this.flag = flag;
    }

       public void run() {
          if (flag) {
          synchronized (MyLock.objA) { 
          System.out.println("true -- objA");//**d1停這了
          synchronized (MyLock.objB) { 
          System.out.println("true -- objB");
       }
      }
     } else {
         synchronized (MyLock.objB) {
         System.out.println("false -- objB");
         synchronized (MyLock.objA) { 
         System.out.println("false -- objA");
     }
   }
  }
 }

}

// 定义一个测试方法 

     public class DieLockDemo {
       public static void main(String[] args) {
        DieLock d1 = new DieLock(true);
         DieLock d2 = new DieLock(false);

           d1.start();
              d2.start();
 }
}

七、加入线程

   方法：public final void join() 等待该线程终止。

   前提是：在加入某个线程之前，要先启动这个线程

   效果： 一旦有join线程，那么当前线程就要等待，直到该线程结束

八、线程优先级

   方法：public final void getPriority() 返回线程的优先级

        public final void setPriority(int newPriority)  修改线程优先级

     优先级的方法是1--10.默认优先级是5

      优先级越高并不代表一定能第一个抢到线程，优先级可以在某种程度上，让线程获得较多的执行机会。

九、暂停线程

   方法： public static void yield() // 暂停当下正在执行的线程对象，并执行其他线程

     什么时候用？

    它可以使线程和谐一些，不至于出现成片同一线程数据