java多线程学习笔记

java多线程

一、引言

通常,用并发结局的问题大体上可以分为“速度”和“设计可管理性”两种。

  • 速度:多线程机制可以通过频繁的线程间切换,有效的避免“阻塞”问题;
  • 设计可管理性:也就是改善代码设计,并发编程更符合人的实际逻辑,可以有效的解决仿真相关的问题。

二、java线程

1.创建与启动

java中通常有两种方式创建线程:

  • 扩展java.lang.Thread类

      public class taskT extends Thread{
          public void run() {
              System.out.println("正在执行Runnable!");
          }
          public static void main(String[] args) {
              Thread t =new taskT();
              t.start();
          }
      }
    
  • 实现java.lang.Runnable接口

      public class taskR implements Runnable{
          @Override
          public void run() {
              System.out.println("正在执行Runnable!");
          }
      }
    
      public static void main(String[] args) {
          taskR r = new taskR();
          Thread thread = new Thread(r);
          thread.start();
      }
    

一旦创建一个新线程并开始执行,即调用start方法时,虚拟机中就又多一个进程,这个进程和原先的进程时并行的。

public class TaskR implements Runnable{
    @Override
    public void run() {
        System.out.println("正在执行线程B!");
        System.out.println("已经执行完线程B!");
    }
}

public class test {
    public static void main(String[] args) {
        System.out.println("正在执行main函数111!");
        TaskR b = new TaskR();
        Thread threadB = new Thread(b);
        System.out.println("准备添加线程B!");
        threadB.start();
        System.out.println("继续执行main函数222!");
//      for (int i = 0; i < 999999; i++);//延时代码
        System.out.println("正在执行main函数333!");
    }
}

如上程序执行结果输出如下:

正在执行main函数111!
准备添加线程B!
继续执行main函数222!
正在执行main函数333!
正在执行线程B!
已经执行完线程B!

将main函数的注释代码去除注释,增加代码延时,输出如下:

正在执行main函数111!
准备添加线程B!
继续执行main函数222!
正在执行线程B!
已经执行完线程B!
正在执行main函数333!

由上两组对比不难发现,当线程threadB一旦开始执行(执行threadbB.start()),main函数这条线程和线程threadB是并发的。

另外需要注意的是,多线程表面上给人的感觉是多个任务同时进行,实际上并非如此,虚拟机通过频繁的切换进程来给人同时执行的错觉。

2.线程状态的转换

线程的状态是线程控制的基础。线程状态总的可以分为五大类:生、等待、阻塞、睡眠、死。

  • 生:线程已经被new,且未执行;
  • start():线程调用start()方法后即进入等待/可运行状态;
  • yield():此外正在执行的线程也可以通过Thread.yield()方法使当前线程暂停执行,并进入可运行状态,从而让步其他线程,但也可能让步失败,因为该线程可能在进入运行状态后又被再次选中。(注:让步的线程是接着执行线程,还是重新执行,经程序测试是接着执行未执行的代码);
  • 阻塞:线程卡死,或不停执行,跳不出run()方法;
  • sleep():调用Thread.sleep()方法,使线程暂停执行一段时间,即睡眠,可以用来帮助其他进程获得运行机会;
  • 死:线程执行完毕,执行完run()方法。

3.线程的同步与锁

当多个线程同时访问互斥(可交换)数据时,应该同步以保护数据,确保两个线程不会同时更改它。通常用synchronized字段实现,而且只能同步方法或同步代码快。

如果两个线程要执行一个类中的synchronized方法,并且两个线程使用相同的实例来调用方法,那么一次只能有一个线程能够执行方法,另一个需要等待,直到锁被释放。

4.线程的交换

  • notify()
  • notifyAll()
  • wait()

5.线程的调度

  • 休眠:Thread.sleep()
  • 优先级
  • 让步:Thread.yield()
  • 合并:join():join()方法是是在某个线程a中,加入一个线程b,线程b没执行完前,a不得执行。

      public class TaskR implements Runnable{
          @Override
          public void run() {     
              System.out.println("正在执行线程B!");
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              System.out.println("已经执行完线程B!");
          }
      }
      public class test {
          public static void main(String[] args) throws InterruptedException {
              System.out.println("正在执行main函数!");
              TaskR b = new TaskR();
              Thread threadB = new Thread(b);
              System.out.println("准备添加线程B!");
              threadB.start();
              System.out.println("执行完main");
          }
      }
      public class test2 {
          public static void main(String[] args) throws InterruptedException {
              System.out.println("正在执行main函数!");
              TaskR b = new TaskR();
              Thread threadB = new Thread(b);
              System.out.println("准备添加线程B!");
              threadB.start();
              System.out.println("threadB.join()");
              threadB.join();
              System.out.println("执行完main");
          }
      }
    

    分别执行test1和test2中的main执行结果如下:

      正在执行main函数!
      准备添加线程B!
      threadB.join()
      执行完main
      正在执行线程B!
      已经执行完线程B!
    

    test2中添加join()方法:

      正在执行main函数!
      准备添加线程B!
      threadB.join()
      正在执行线程B!
      已经执行完线程B!
      执行完main
    

    在threadB中调用sleep是为了让main函数这条线程获得执行机会。有结果,可知当threadB调用join方法后,即使sleep了main函数都不能跑完,说明join方法的作用,即必须threadB执行完才能继续执行main函数。

  • 守护线程

线程池

java.util.concurrent.Executors。 例:

ExecutorService pool = Executors.newFixedThreadPool(2);
Thread t1 = new MyThread(); 
Thread t2 = new MyThread();
Thread t3 = new MyThread();
Thread t4 = new MyThread();
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.shutdown();

posted on 2014-12-07 16:46  凡高是我吗  阅读(360)  评论(0编辑  收藏  举报

导航