A股上市公司传智教育（股票代码 003032）旗下技术交流社区北京昌平校区

传智教育官网黑马程序员官网

 找回密码
 加入黑马

QQ登录

只需一步，快速开始

论坛首页 › 学习交流 › 技术交流 › Java技术交流 › 正文

[学习交流] 黑马程序员——基础篇——多线程

© Himoriarty 中级黑马   /  2015-6-10 13:58  /  298 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

------- <a  target="blank">android培训</a>、<a  target="blank">java培训</a>、期待与您交流！ ----------

1、创建线程的方式：实现Runnable接口
步骤：
      1、定义类实现Runnable接口。
      2、覆盖Runnable接口中的run方法。
      3、通过Thread类建立线程对象。
      4、将Runnable接口的子类对象作为实际参数传递给Thead类的构造函数。
为什么要将Runnable接口的子类对象传递给Thread的构造函数，因为自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。
       5、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

  1. <div class="blockcode"><blockquote>/**
  2. 创建两个线程，和主线交替运行
  3. */

  5. class Test extends Thread
  6. {
  7.        
  8.         Test(String name)
  9.         {
  10.                         super(name);
  11.         }
  12.         public void run()
  13.         {
  14.                
  15.                 for(int x = 0; x < 60;x ++)
  16.                 {
  17.                         System.out.println("test run..." + x + super.currentThread().getName());
  18.                 }
  19.         }
  20. }

  22. class ThreadTest
  23. {
  24.         public static void main(String[] args)
  25.         {
  26.                 Test t1 = new Test("one");
  27.                 Test t2 = new Test("two");
  28.                
  29.                 t1.start();
  30.                 t2.start();
  31.                
  32.                 for(int x = 0; x < 60; x ++)
  33.                 {
  34.                         System.out.println("main..." + x);
  35.                 }
  36.         }
  37. }
复制代码




2、实现方式和继承方式
         实现方式的好处：避免了单继承的局限性，在定义线程时，建立使用实现方式。
        两种方式的区别：
               继承Thread：线程代码存放Thread子类run方法中；
               实现Runnable;线程代码存在接口的子类的run方法。

3、多线程的安全问题：
           原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完。另一个线程参与进来执行，导致共享数据的错误。
          解决办法：对多条操作共享数据的语句，只能让一个线程执行完，在执行过程中，其他线程不可以参与执行。
  1. <div class="blockcode"><blockquote>/**
  2. 死锁例子
  3. */

  5. class Test implements Runnable
  6. {
  7.         private boolean p;
  8.         Test(boolean p)
  9.         {
  10.                 this.p = p;
  11.         }
  12.        
  13.         public void run()
  14.         {
  15.                 if(p)
  16.                 {
  17.                         synchronized(Mylock.locka)
  18.                         {
  19.                                 System.out.println("if locka");
  20.                                 synchronized(Mylock.lockb)
  21.                                 {
  22.                                         System.out.println("if lockb");
  23.                                 }
  24.                         }
  25.                 }
  26.                 else
  27.                 {
  28.                         synchronized(Mylock.lockb)
  29.                         {
  30.                                 System.out.println("else lockb");
  31.                                 synchronized(Mylock.locka)
  32.                                 {
  33.                                         System.out.println("else locka");
  34.                                 }
  35.                         }
  36.                 }
  37.         }
  38. }

  40. class Mylock
  41. {
  42.         static Object locka = new Object();
  43.         static Object lockb = new Object();
  44. }
  45. public class DeadLock
  46. {
  47.         public static void main(String[] args)
  48.         {
  49.                 Thread t1 = new Thread(new Test(true));
  50.                 Thread t2 = new Thread(new Test(false));
  51.                
  52.                 t1.start();
  53.                 t2.start();
  54.         }
  55. }
复制代码



4、Java对于多线程的安全问题提供了专业的解决方式。就是同步代码块。
        Syschronized(对象（可以使用Object类）)
        {
                      需要被同步的代码；
        }
       此处对象为什么必须要建在run函数外部？此对象如同锁，持有锁的线程可以在同步中执行，没有持有锁的线程即使获取cpu的执行权也进不去，因为没有获取锁。
       同步的前提：
      1、必须要有两个或两个以上的线程；
      2、必须是多个线程使用同一个锁；
      3、必须保证同步中只能有一个线程在进行。
好处：解决了多线程的安全问题。
  1. <div class="blockcode"><blockquote>/**
  2. 需求：简单的卖票程序。
  3. 多个窗口同时卖票

  5. */

  7. class Ticket implements Runnable     
  8. {
  9.         private int tick = 100;
  10.         Object object = new Object();
  11.         public void run()
  12.         {
  13.                 synchronized(object)
  14.                 {
  15.                 while(true)
  16.                 {
  17.                        
  18.                                 if(tick > 0)
  19.                                 {
  20.                                         try{Thread.sleep(10);} catch(Exception e) {}
  21.                                         System.out.println(Thread.currentThread().getName() + "sale : " + tick--);
  22.                                 }
  23.                        
  24.                         if(tick <= 0)
  25.                                 break;
  26.                 }
  27.                 }
  28.         }
  29. }

  31. class TicketThread
  32. {
  33.         public static void main(String[] args)
  34.         {
  35.                
  36.                 Ticket t = new Ticket();
  37.                
  38.                 Thread t1 = new Thread(t);
  39.                 Thread t2 = new Thread(t);
  40.                 Thread t3 = new Thread(t);
  41.                 Thread t4 = new Thread(t);
  42.                
  43.                 t1.start();
  44.                 t2.start();
  45.                 t3.start();
  46.                 t4.start();
  47.         }
  48. }
复制代码




----------android培训、java培训、java学习型技术博客、期待与您交流！------------
程序员多线程

0 个回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 加入黑马