码迷，mamicode.com
首页 > 编程语言 > 详细

黑马程序员__多线程

时间：2015-05-11 08:55:28      阅读：217      评论：0      收藏：0      [点我收藏+]

标签：黑马程序员   java   编程   语言   

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------


1.线程是程序执行的一条路径, 一个进程中可以包含多条线程，多线程并发执行可以提高程序的效率, 可以同时完成多项工作。

2.开启新线程的两种方式
 1).继承Thread

[java] view plaincopy
  1. public static void main(String[] args) {  
  2.     MyThread mt = new MyThread();       //4,创建自定义类对象  
  3.     mt.start();             <span style="font-family:宋体;">//5,开启线程  
  4. </span>   for(int i = 0; i < 10000; i++) {  
  5.     System.out.println("传智播客");  
  6.         }  
  7.     }  
  8.   
  9. }  
  10.   
  11. class MyThread extends Thread {                     //1,自定义类继承Thread  
  12.     public void run() {                     //2,重写run方法  
  13.         for(int i = 0; i < 10000; i++) { //3,将要执行的代码写在run方法中  
  14.             System.out.println("黑马程序员");  
  15.         }  
  16.     }  
  17. }  


 2).实现Runnable

[java] view plaincopy
  1. public static void main(String[] args) {  
  2.         MyRunnable mr = new MyRunnable();//4,创建自定义类对象  
  3.         Thread t = new Thread(mr);   //5,将自定义类对象当作参数传递给Thread的构造函数    
  4.         t.start();           //6,开启线程  
  5.           
  6.         for(int i = 0; i < 10000; i++) {  
  7.             System.out.println("传智播客");  
  8.         }  
  9.     }  
  10.   
  11. }  
  12.   
  13. class MyRunnable implements Runnable {      //1,自定义类实现Runnable接口  
  14.   
  15.     @Override  
  16.     public void run() {         //2,重写run方法  
  17.         for(int i = 0; i < 10000; i++) {//3,将要执行的代码写在run方法中  
  18.             System.out.println("黑马程序员");  
  19.         }  
  20.     }  
  21. }  

3.Thread类常用方法
 获取名字： getName()方法
 设置名字：通过构造函数可以传入String类型的名字或通过setName(String)方法可以设置线程对象的名字
 获取当前线程对象：Thread.currentThread()
 休眠：Thread.sleep(毫秒,纳秒)
 守护：setDaemon()
 加入：

   join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
    join(int), 可以等待指定的毫秒之后继续

 让出cpu：yield
 设置线程的优先级：setPriority()

[java] view plaincopy
  1. public static void main(String[] args) {  
  2.         final Thread t1 = new Thread() {  
  3.             public void run() {  
  4.                 for(int i = 0; i < 50; i++) {  
  5.                     try {  
  6.                         Thread.sleep(10);//休眠  
  7.                     } catch (InterruptedException e) {  
  8.                         // TODO Auto-generated catch block  
  9.                         e.printStackTrace();  
  10.                     }  
  11.                     System.out.println(getName() + "...传智播客");  
  12.                 }  
  13.             }  
  14.         };  
  15.           
  16.         Thread t2 = new Thread(new Runnable(){  
  17.             public void run() {  
  18.                 for(int i = 0; i < 50; i++) {  
  19.                     if(i == 2) {  
  20.                     try {  
  21.                     //t1.join();//让出cpu,只有t1完全执行完,再执行t2  
  22.                     t1.join(1);//让出cpu,但是只让出1毫秒,就是指定参数的时间  
  23.                     } catch (InterruptedException e) {  
  24.                               
  25.                         e.printStackTrace();  
  26.                     }  
  27.                     }  
  28.             System.out.println(Thread.currentThread().getName() + "...黑马程序员");  
  29.                 } //获取当前线程对象  
  30.             }  
  31.         });  
  32.         t1.setDaemon(true); //设置t1为守护线程  
  33.         t1.start();  
  34.         t2.start();  
  35.     }  


4.线程之间的同步

 线程之间的同步有同步代码块和同步方法

 同步代码块是使用synchronized关键字加上一个锁对象来定义一段代码，多个同步代码块使用相同的锁对象
 同步方法是使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的，非静态同步方法默认使用当 前对象this作为锁对象，静态方同步函数的锁是该类的字节码对象。字节码对象可以认为是万能锁。

 要注意的是多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁，所以尽可能不要嵌套使用。

例如：模拟售票，总数为一千张，有四个窗口卖票：


[java] view plaincopy
  1. public class Ticket {  
  2.     public static void main(String[] args) {  
  3.         new TicketsSeller().start();    //开启线程  
  4.         new TicketsSeller().start();  
  5.         new TicketsSeller().start();  
  6.         new TicketsSeller().start();  
  7.     }  
  8.   
  9. }  
  10.   
  11. class TicketsSeller extends Thread {  
  12.     private static int tickets = 1000;  
  13.     public void run() {  
  14.         while(true) {  
  15.             synchronized(TicketsSeller.class) {  
  16.                 if(tickets == 0)      
  17.                     break;    
  18.                 try {  
  19.                     Thread.sleep(10);//增强效果  
  20.                 } catch (InterruptedException e) {  
  21.                     e.printStackTrace();  
  22.                 }  
  23.                 System.out.println(getName() + "...这是第" + tickets-- + "号票");//卖票,并将结果--  
  24.             }  
  25.         }  
  26.     }  
  27. }  

5.单例设计模式

单例设计模式：保证类在内存中只有一个对象。
 (1)将构造方法私有。
 (2)在本类中定义一个本类的对象。Singleton s;
 (3)提供公共的访问方式。public static Singleton getInstance(){return s}

 单例写法两种：饿汉式，懒汉式；

饿汉式：

[java] view plaincopy
  1. class Singleton{  
  2.     private Singleton(){}  
  3.     private static Singleton s=new Singleton();  
  4.     public static Singleton getInstance(){  
  5.             return s;  
  6.       }  
  7. }  

懒汉式：

[java] view plaincopy
  1. class Singleton{  
  2.         private Sinleton(){}  
  3.         private static Singleton s;  
  4.         public static Sinleton getInstance(){  
  5.              if(s==null){  
  6.                 s=new Sinleton();}  
  7.                 return s;  
  8.           }  
  9. }  


第三种格式：

[java] view plaincopy
  1. class Singleton {  
  2.         private Singleton() {}  
  3.   
  4.         public static final Singleton s = new Singleton();//final是最终的意思,被final修饰的变量不可以被更改  
  5.     }  


6.线程之间的通信
  线程等待, wait()
  唤醒等待  notify();
  这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用
  多个线程通信的问题
  notify()方法是随机唤醒一个线程
  notifyAll()方法是唤醒所有线程
  JDK5之前无法唤醒指定的一个线程
  如果多个线程之间通信, 需要使用notifyAll()通知所有线程, 用while来反复判断条件

[java] view plaincopy
  1. public class Demo6_Notify {  
  2.     public static void main(String[] args) {  
  3.         final Printer p = new Printer();  
  4.         new Thread() {  
  5.             public void run() {  
  6.                 while(true) {  
  7.                     try {  
  8.                         p.print1();  
  9.                     } catch (InterruptedException e) {  
  10.                           
  11.                         e.printStackTrace();  
  12.                     }  
  13.                 }  
  14.             }  
  15.         }.start();  
  16.           
  17.         new Thread() {  
  18.             public void run() {  
  19.                 while(true) {  
  20.                     try {  
  21.                         p.print2();  
  22.                     } catch (InterruptedException e) {  
  23.                           
  24.                         e.printStackTrace();  
  25.                     }  
  26.                 }  
  27.             }  
  28.         }.start();  
  29.     }  
  30.   
  31. }  
  32.   
  33. class Printer {  
  34.     private int flag = 1;  
  35.     public void print1() throws InterruptedException {  
  36.         synchronized(this){  
  37.             if(flag != 1)  
  38.                 this.wait();                            //线程等待  
  39.             System.out.print("传");  
  40.             System.out.print("智");  
  41.             System.out.print("播");  
  42.             System.out.print("客");  
  43.             System.out.print("\r\n");  
  44.             flag = 2;                               //flag改为2  
  45.             this.notify();                              //唤醒等待的线程  
  46.         }  
  47.     }  
  48.       
  49.     public void print2() throws InterruptedException {  
  50.         synchronized(this){  
  51.             if(flag != 2)   
  52.                 this.wait();                            //线程等待  
  53.               
  54.             System.out.print("黑");  
  55.             System.out.print("马");  
  56.             System.out.print("程");  
  57.             System.out.print("序");  
  58.             System.out.print("员");  
  59.             System.out.print("\r\n");  
  60.             flag = 1;                               //flag改为1  
  61.             this.notify();                              //唤醒等待的线程  
  62.         }  
  63.     }  


7.JDK5之后的线程控制
 同步
  使用ReentrantLock类的lock()和unlock()方法进行同步
 通信
  使用ReentrantLock类的newCondition()方法可以获取Condition对象
  需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法
  不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了

[java] view plaincopy
  1. package cn.itcast.thread;  
  2.   
  3. import java.util.concurrent.locks.Condition;  
  4. import java.util.concurrent.locks.ReentrantLock;  
  5.   
  6. public class Demo8_ReentrantLock{  
  7.     public static void main(String[] args) {  
  8.         final Printer3 p = new Printer3();  
  9.         new Thread() {  
  10.             public void run() {  
  11.                 while(true) {  
  12.                     try {  
  13.                         p.print1();  
  14.                     } catch (InterruptedException e) {  
  15.                           
  16.                         e.printStackTrace();  
  17.                     }  
  18.                 }  
  19.             }  
  20.         }.start();  
  21.           
  22.         new Thread() {  
  23.             public void run() {  
  24.                 while(true) {  
  25.                     try {  
  26.                         p.print2();  
  27.                     } catch (InterruptedException e) {  
  28.                           
  29.                         e.printStackTrace();  
  30.                     }  
  31.                 }  
  32.             }  
  33.         }.start();  
  34.           
  35.         new Thread() {  
  36.             public void run() {  
  37.                 while(true) {  
  38.                     try {  
  39.                         p.print3();  
  40.                     } catch (InterruptedException e) {  
  41.                           
  42.                         e.printStackTrace();  
  43.                     }  
  44.                 }  
  45.             }  
  46.         }.start();  
  47.     }  
  48.   
  49. }  
  50.   
  51. class Printer3 {  
  52.     private ReentrantLock r = new ReentrantLock();          //创建锁对象  
  53.     private Condition c1 = r.newCondition();                //添加监视器  
  54.     private Condition c2 = r.newCondition();  
  55.     private Condition c3 = r.newCondition();  
  56.     private int flag = 1;  
  57.     public void print1() throws InterruptedException {  
  58.         r.lock();                       //获取锁  
  59.             if(flag != 1)  
  60.                 c1.await();             //线程等待  
  61.             System.out.print("传");  
  62.             System.out.print("智");  
  63.             System.out.print("播");  
  64.             System.out.print("客");  
  65.             System.out.print("\r\n");  
  66.             flag = 2;                       //flag改为2  
  67.             c2.signal();                    //唤醒线程2  
  68.         r.unlock();                     //释放锁  
  69.     }  
  70.       
  71.     public void print2() throws InterruptedException {  
  72.         r.lock();                       //获取锁  
  73.             if(flag != 2) {  
  74.                 c2.await();             //线程等待,2线程等待  
  75.             }  
  76.             System.out.print("黑");  
  77.             System.out.print("马");  
  78.             System.out.print("程");  
  79.             System.out.print("序");  
  80.             System.out.print("员");  
  81.             System.out.print("\r\n");  
  82.             flag = 3;                   //flag改为3  
  83.             c3.signal();                    //唤醒线程3  
  84.         r.unlock();                     //释放锁  
  85.     }  
  86.       
  87.     public void print3() throws InterruptedException {  
  88.         r.lock();                       //获取锁  
  89.             if(flag != 3) {  
  90.                 c3.await();             //线程等待,3线程等待  
  91.             }  
  92.             System.out.print("i");  
  93.             System.out.print("t");  
  94.             System.out.print("c");  
  95.             System.out.print("a");  
  96.             System.out.print("s");  
  97.             System.out.print("t");  
  98.             System.out.print("\r\n");  
  99.             flag = 1;                   //flag改为1  
  100.             c1.signal();                    //唤醒线程1  
  101.         r.unlock();                     //释放锁  
  102.     }  
  103. }  

黑马程序员__多线程

标签：黑马程序员   java   编程   语言   

原文地址：http://blog.csdn.net/haojude/article/details/45631191
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！