黑马程序员---Java中的线程

                                                 关于Java中的线程

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

1. 进程

  进程：正在运行的程序，所占有内存空间

  程序存储在硬盘，运行时期到了内存中

  线程：是一个大程序中的子程序

  CPU真正执行的是线程，子程序对于CPU来讲独立执行路径，路径就是线程

//======================================================

2. Java中创建线程

  任何都是对象，线程也是对象，对象的描述类

  java.lang.Thread类

  创建线程的第一种方式，继承Thread类，重写run方法

  创建Thread子类对象

  调用子类中的方法start()开启线程

   void start()

          使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

  JVM 本身是单线程的程序，还是多线程的程序

  一个线程运行我们写的程序，一个线程不定时收取垃圾，JVM帮助你调用Windows中的功能

  为什么继承Thread类，入伙，继承Thread类，子类就是一个线程了

  为什么重写run方法 Thread中的run方法是空方法，等待子类重写

  线程运行的程序是什么，未知的,Java工程师，开放多线程技术的时候

  不知道使用Java编程的人员会运行哪些代码

  提供一个标准，就是run方法：不管线程运行哪些代码，必须放在run中，线程就运行你run中的代码

/*

 * 创建线程第一种方式，继承Thread类

 */

class Demo1 extends Thread{

 public void run(){

  for(int x = 0 ; x < 50 ;x++){

   System.out.println("run..."+x);

  }

 }

}

public class ThreadDemo1 {

 public static void main(String[] args) {

  while(true){

  Demo1 d = new Demo1();

  d.start();//开启线程，JVM自动调用线程的run方法

  for(int x = 0 ; x < 50 ; x++){

   System.out.println("main..."+x);

  }

  }

 }

}

//======================================================

4. 线程的状态图，必须自己会画

5. 线程名字的获取和设置

  获取名字，Thread类的方法getName(),返回字符串

  线程名字JVM命名的 Thread-0 Thread-1

  在Thread子类中，直接使用父类方法getName()获取名字

  在不是Thread子类中，获取线程名字

  Thread类中，提供了一个静态方法 currentThread()返回值是一个Thread类的对象

  方法，返回当前线程对象，既然返回的是对象，方法调用链

   String name = Thread.currentThread().getName();

  设置线程的名字：

    Thread类的方法setName()

    Thread类的构造方法

      Thread(String name)传递线程名字

    Thread子类中，super语句将线程的名字送到父类构造方法

class ThreadName extends Thread{

 ThreadName(String name){

  super(name);

 }

 public void run(){

  String name =Thread.currentThread().getName();

  System.out.println(name+" 线程ThreadName");

 }

}

public class ThreadDemo {

 public static void main(String[] args) {

  //Thread.currentThread();//返回的就是运行main方法的线程对象

  String name = Thread.currentThread().getName();

  System.out.println(name);

  ThreadName t1 = new ThreadName("西班牙0");

  ThreadName t2 = new ThreadName("智利2");

 

 // t1.setName("小强");

 // t2.setName("旺财");

 

  t1.start();

  t2.start();

 }

}

//======================================================

6. 售票的一个案例

  利用多线程模拟多窗口一起售票

  模拟出了，卡机线程，导致了数据的安全问题

  多线程操作同一个数据的时候，出现数据安全问题

 

   解决办法：一个线程不执行完毕，其他的线程，不能执行

 

  Java中开放出了同步技术，保证线程的安全性，会阻止其他线程进入

  同步代码块

    synchronized(任意对象){

   

       线程操作的共享数据

    }

/*

 * 模拟售票4个窗口一起出售

 * 改造成实现Runnable接口的方式

 */

class Ticket implements Runnable{

 private int tickets = 100;

 private Object obj = new Object();

 public void run(){

  while(true){

   synchronized(obj){

   if(tickets > 0){

    //线程if判断完毕后，休眠一段时间

    try{

    Thread.sleep(67);

    }catch(Exception e){}

    System.out.println(Thread.currentThread().getName()+"..出售第.."+tickets--);

   }

   }

  }

 }

}

public class ThreadDemo1 {

 public static void main(String[] args) {

  //创建Ticket对象

  Ticket t = new Ticket();

  //创建Thread类对象，传递Runnable接口的实现类对象

  Thread t1 = new Thread(t);

  Thread t2 = new Thread(t);

  Thread t3 = new Thread(t);

  Thread t4 = new Thread(t);

  t1.start();

  t2.start();

  t3.start();

  t4.start();

 }

}

//======================================================

7. 创建线程的第二种方式

  定义类，实现Runnable接口

  重写run方法

  class A implements Runnable{

        public void run(){

 }

  }

  A类不再是线程类了

  直接创建Thread类对象

  构造方法Thread(Runnable target) 接受的数据类型是Runnable接口的子类类型

  new Thread(new A()); 

  调用Thread类中的start();

  两个线程的创建方式的区别

  继承Thread类，实现Runnable接口区别

  继承，单继承局限性

  接口，多现实，避免了单继承的局限性

  继承Thread类方式，线程中的数据是对象自己的

  实现接口方法，线程中的数据是共享的

  写多线程程序推荐使用接口方式

//======================================================

8. 同步的原理

    synchronized(任意对象){

   

       线程操作的共享数据

    }

 

  对象，写在了同步中

  专业名词，对象监视器

  通俗一点：锁

  线程进到同步代码块后，线程获取这把锁，这扇门永久关闭了

  当线程出去同步代码块，将锁释放

  厕所原理

  多线程操作同一个数据，安全问题

  如果是单线程，没有数据安全问题

//======================================================

9. 模拟存钱

  一张卡，可以多个柜台存钱

  余额是0，每个柜台每次存100元

  两个柜台，每个存3次

  600元，没存一次，查看余额

  同步方法，在方法的声明上写同步关键字

  线程每次只有一个运行这个方法

  当方法中所有代码都是线程操作的的共享数据

  同步方法中，锁是什么

  确定的是，锁肯定有，锁必须是对象

  锁是本类的对象引用this

  方法中的同步代码块，锁直接写this

  静态方法中的，同步锁是谁

  锁是对象！

  静态优先于对象，静态中的锁，是本类的class文件对象

  Java中，每一个数据类型，JVM都赋予他们一个静态成员变量

  class名字，变量的运行结果就是类的class文件对象

  静态方法中的锁，就是本类.class字节码文件对象

/*

 * 存钱的时候

 * 卡，钱，到银行中去，银行柜台存钱

 * 但是，整个Add方法中的所有代码，都是线程操作的共享数据

 * 没有必要同步一段代码，同步整个方法

 */

class Bank{

 //存钱功能，存一次，看余额

 private static int sum = 0;

 public static synchronized void add(int money){

 // synchronized(Bank.class){

  sum = sum + money;

  System.out.println(sum);

 // }

 }

}

class Customer implements Runnable{

 private Bank b = new Bank();

 public void run(){

  for(int x = 0 ; x < 3 ; x++){

  Bank.add(100);

  }

 }

}

public class ThreadDemo2 {

 public static void main(String[] args) {

  Customer c = new Customer();

  Thread t1 = new Thread(c);

  Thread t2 = new Thread(c);

  t1.start();

  t2.start();

 }

}

//==============================================================

10. 单例模式

  懒汉有安全隐患，多线程并发访问懒汉式的时候

  安全问题，同步避免

  效率很低，提高懒汉的效率

  第一次执行s=null

  进同步 创建对象，返回

  第二次执行s!=null

  没有必要进同步了，直接返回

  两次判断，提高效率

class Single{

 private Single(){}

 private static Single s = null;

 public static Single getInstance(){

 

  if(s == null){

 

  synchronized(Single.class){

  if( s == null)

   s = new Single();

        }

  }

 

  return s;

 }

}

class SingleThead implements Runnable{

 public void run(){

  for(int x = 0 ; x < 30 ; x++){

   Single s = Single.getInstance();

   System.out.println(s);

  }

 }

}

//==============================================================

11. 死锁案例

  在多线程的技术中，两个或者两个以上的线程，同时争夺一个对象监视器

  导致程序的假死现象

  死锁：出现条件，必须多线程，争夺一个锁，程序中，体现在同步代码块的嵌套效果

  死锁的案例，面试过程中经常被考到

//==============================================================

12. 线程的通信

  两个线程同时对一个资源对象，进行赋值和取值操作

  思考，数据安全问题怎么发生的

  发生后，怎么解决

  数据安全问题：线程的随机性导致程序数据安全隐患

  采用了同步技术，依然没有解决

  当你发现数据安全问题后，使用了同步技术，还是不能解决

    第一点，确定程序是不是多线程在操作共享数据 确定

    第二点，使用的同步中的锁，是同一把锁吗，锁不同唯一的

      必须将锁变成唯一的对象，才能控制数据安全问题

      资源对象，数据的安全性解决了

  线程等待和唤醒的方法

  没有出现在线程描述类Thread类中

  方法定义在了Object类中，为什么这样设计

  原因是锁，锁是一个对象，对象是通过类new出来的

  锁是哪一个类的对象，无法确定的

  但是将方法写在Object类中，所有的类的对象，都具有线程的等待与唤醒方法

  wait()方法的使用，将线程永久等待，直到有人唤醒

  wait方法必须有锁的支持，wait方法必须写在同步中

  锁是唯一的

  synchronized(r){

     wait();

     notify();

  }

  synchronized(r){

     notify()

  }

  IllegalMonitorStateException

  异常，运行时期的异常，抛出该异常，说明wait notify没有锁的支持，没有对象监视器

/*

 * 线程通信的代码的优化

 */

//定义资源类，私有处理

class Recource{

 private String name;

 private String sex;

 private boolean flag = false;

 //提供get set方法，访问成员变量

 public synchronized void set(String name,String sex){

  if(flag)

   try{

   this.wait();

   }catch(Exception e){}

  this.name = name;

  this.sex = sex;

  flag = true;

  this.notify();

 }

 public synchronized void get(){

  if(!flag)

   try{

   this.wait();

   }catch(Exception e){}

  System.out.println(name+"..."+sex);

  flag = false;

  this.notify();

 }

}

//输入线程

class Input implements Runnable{

 private Recource r;

 Input(Recource r){this.r = r;}

 public void run(){

  int x = 0 ;

  while(true){

   if(x %2 == 0){

    r.set("张三", "男");

   }else{

    r.set("李四", "女");

   }

   x++;

  }

 }

}

//输出的线程

class Output implements Runnable{

 private Recource r ;

 Output(Recource r){this.r=r;}

 public void run(){

  while(true){

   r.get();

  }

 }

}

public class ThreadDemo5 {

 public static void main(String[] args) {

  Recource r = new Recource();

  new Thread(new Input(r)).start();

  new Thread(new Output(r)).start();

 }

}

//==============================================================

13. wait() sleep() 导致线程等待，两个方法区别在哪里(不要光看表面。)

  

  sleep(毫秒值)自动醒来

  wait()永久等待，需要别的线程唤醒

  sleep()方法是Thread类的静态方法

  wait()方法是Object类的非静态方法

  sleep()不需要对象锁

  wait()必须有锁的支持

  sleep()方法，执行的时候线程不会释放对象锁

  wait()方法，执行的时候，线程放弃对象锁，被唤醒的时候，从新获取对象锁，才能运行

//==============================================================

14. 定时器

  Java程序中，有定时功能，按照一定的时间间隔运行指定的程序

  定时器类，java.util.Timer

  构造方法

    Timer(boolean isDaemon) false 不是守护的线程

    schedule(TimerTask task, Date firstTime, long period)

                       定时器任务              第一次时间         间隔

  抽象类 TimerTask 时间任务，定时器执行的程序，写在这个类的run方法

/*class Time extends TimerTask{

 public void run(){

  System.out.println("定时2秒钟发送一次邮件");

 }

}*/

public class TimerDemo {

 public static void main(String[] args) {

  Timer t = new Timer(false);

 

  t.schedule(new TimerTask(){

   public void run(){

    System.out.println("\"定时2秒钟发送一次邮件\"");

   }

  }, new Date(), 3600000);

 

  System.out.println("main...over");

 }

}

//==============================================================

15. 多线程通信，生产者与消费者

  一个产品，分别线程控制，一个控制生产，一个控制消费

  生产一个，消费一个，多生产者，多消费者

  多个生产与多个消费，全部的唤醒notifyAll()

  唤醒以后，数据安全性还是没解决

  线程在wait上等待，被唤醒的时候，从Wait这里起来

  起来以后，不会再次判断flag是true,还是false,因此数据问题，没哟解决

  线程，被唤醒以后，但是判断标记！！

  用的是循环的方式，解决线程倒下去后，再起来，必须还要判断标记

  但是发现一个问题：

    notifyAll()唤醒了全部等待的线程

    1个活的，7个等着，全部醒来

    浪费资源，能不能唤醒对方的一个线程的

    生产者，只唤醒一个消费者

    消费者，只唤醒一个生产者

    唤醒本方是没有意义，全部唤醒是浪费资源的

    Java的JDK1.4版本之前，是做不到了

    到了JDK1.5版本后，就可以实现了

    提供一套新的多线程的操作方式

    synchronized,被替换了

    wait(),notify(),notifyAll()，被替换了

    JDK1.5的新特性，线程锁定操作

    导包 java.util.concurrent.locks

//==============================================================

16. JDK1.5的锁 lock接口

  Lock接口--synchronized同步

  同步是有锁提供

  接口中，定义了两个方法 lock() unlock()

  要同步线程的时候，使用这两个方法，进行锁操作

  Lcok接口的实现类对象ReentrantLock

  获取到接口的实现类对象，调用方法，锁操作

  新的技术中，JDK提供了一个接口Condition

  替换了原有线程方法,wait,notify

  将线程进行分组管理

  t1-t4 set方法，用锁就是set方法中的锁

  t5-t8 get方法，用锁就是get方法中的锁

  一个lock接口上，可以实现多个Condition对象

  final Condition notFull = lock.newCondition();

  final Condition notEmpty = lock.newCondition();

  将一个接口Lock，分成两组管理

  Condition接口中的三个方法

   await() -- wait()

   signal() -- notify()

   signalAll() -- notifyAll();

/*

 * 将案例，改造成lock锁方式实现功能

 */

import java.util.concurrent.locks.*;

class Product{

 private String name;

 //定义计数器

 private int count ;

 //定义标识

 private boolean flag = false;

 //定义Lock锁对象

 private Lock lock = new ReentrantLock();

 //通过Lock接口，获取Condition对象

 private Condition pro = lock.newCondition();

 private Condition cus = lock.newCondition();

 

 //定义生产方法

 public void set(String name){

  //获取锁

  lock.lock();

  while(flag)

   try{

     pro.await();

   }catch(Exception e){}

  this.name = name + count++;

  System.out.println(Thread.currentThread().getName()+"生产第..."+this.name);

  flag = true;

  //this.notifyAll();

  //释放锁

  cus.signal();

  lock.unlock();

 }

   //定义消费方法

 public void get(){

  lock.lock();

  while(!flag)

   try{

   cus.await();

   }catch(Exception e){}

  System.out.println(Thread.currentThread().getName()+"消费第........."+this.name);

  flag = false;

  //this.notifyAll();

  pro.signal();

  lock.unlock();

 }

}

//定义生产者

class Producter implements Runnable{

 private Product p ;

 Producter(Product p){this.p = p;}

 public void run(){

  while(true){

   p.set("键盘");

  }

 }

}

//定义消费这

class Customer implements Runnable{

 private Product p ;

 Customer(Product p){this.p = p;}

 public void run(){

  while(true){

   p.get();

  }

 }

}

public class ThreadDemo {

 public static void main(String[] args) {

  Product p = new Product();

  Producter producter = new Producter(p);

  Customer customer = new Customer(p);

  Thread t1 = new Thread(producter);

  Thread t2 = new Thread(producter);

  Thread t3 = new Thread(producter);

  Thread t4 = new Thread(producter);

  Thread t5 = new Thread(customer);

  Thread t6 = new Thread(customer);

  Thread t7 = new Thread(customer);

  Thread t8 = new Thread(customer);

  t1.start();

  t2.start();

  t3.start();

  t4.start();

  t5.start();

  t6.start();

  t7.start();

  t8.start();

 }

}

//==========================================================

17. 线程的停止方式

  Thread类中，有一个方法stop(),过时

  终止线程的运行，目的结束run方法就行

  停止线程的第一种方式，改变变量的值，结束while循环，结束了run方法

  

处于等待中的线程，怎么停下

  例子：

    我有一个朋友，失眠，找了一个催眠大师(水平很高)

    进行了催眠，朋友就睡了(wait())

    催眠师说，被我催眠的人，只有我能叫醒

    催眠师死了，不能让朋友永久的等待下去

    拍你一板砖，醒来，收到了伤害(异常)

 

  线程的第二种停止方式

    void interrupt() + 异常停下，等待中的线程

    打击线程方法，处于等待的线程，将会抛出异常

/*

 * 线程如何停止下来

 */

class StopThread implements Runnable{

 private boolean flag = true;

 public void run(){

  while(flag){

   synchronized(this){

    try{this.wait();}catch(Exception e){

     e.printStackTrace();

     //System.out.println(e.getMessage()+"打你一板砖");

     flag = false;

    }

   System.out.println("run....");

   }

  }

 }

 public void setFlag(boolean flag){

  this.flag = flag;

 }

}

public class ThreadDemo1 {

 public static void main(String[] args) {

  StopThread st = new StopThread();

  Thread t = new Thread(st);

  t.start();

  for(int x = 0 ; x < 1000 ; x++){

  if(x==999)

      //st.setFlag(false);

   t.interrupt();

  else

   System.out.println("main"+x);

  }

 }

}

//==========================================================

18. 守护线程

  Thread类中。setDaemon(boolean )传递是true,线程守护线程

  如果所有运行的线程，都是守护线程，JVM退出

  方法，必须在start开始前调用

  Feiq,开启多个聊天窗口的时候，一旦关闭飞秋主程序，聊天窗口也就关闭了

  聊天窗口线程，就是飞秋主线程的守护线程，一旦主线程死亡，所有的守护线程就死亡

/*

 * 守护线程

 */

class ThreadDaemon implements Runnable{

 public void run(){

  while(true)

  System.out.println("run....");

 }

}

public class ThreadDemo2 {

 public static void main(String[] args) {

  ThreadDaemon td = new ThreadDaemon();

  Thread t = new Thread(td);

  t.setDaemon(true);

  t.start();

 }

}

//==========================================================

19. Thread中其他方法，toString() setPriority() join() yield()

  toString()继承Object，重写toString()

  Thread[Thread-0,5,main]

  5 优先级，main 线程组

  优先级三个级别，最低，默认，最高

  setPriority(int )设置优先级

  但是优先级的效果，多核，多线程的CPU上，效果不是很明显了

  join() 加入 等待该线程终止

  使用join方法的线程，不停止，其他线程运行不了

  static yield()

/*

 * 线程的让步方法，static yield

 */

class YieldThread implements Runnable{

 public void run(){

  for(int x = 0 ; x < 100 ; x++){

   Thread.yield();

   System.out.println(Thread.currentThread().getName()+"run.."+x);

  }

 }

}

public class ThreadDemo5 {

 public static void main(String[] args) {

  YieldThread yt = new YieldThread();

  Thread t0 = new Thread(yt);

  Thread t1 = new Thread(yt);

  t0.start();

  t1.start();

 }

}

/*

 * 等待该线程终止

 */

class JoinThread implements Runnable{

 public void run(){

  for(int x = 0 ; x < 100; x++){

   System.out.println(Thread.currentThread().getName()+"run.."+x);

  }

 }

}

public class ThreadDemo4 {

 public static void main(String[] args) throws Exception{

  JoinThread jt = new JoinThread();

  Thread t0 = new Thread(jt);

  Thread t1 = new Thread(jt);

     t0.start();

     t0.join();

     t1.start();

  for(int x = 0 ;x < 100 ; x++){

   System.out.println("main...."+x);

  }

 }

}

/*

 * Thread中的toString()

 */

class ThreadToString implements Runnable{

 public void run(){

  for(int x = 0 ; x < 100 ; x++){

   System.out.println(Thread.currentThread().getName()+"run.."+x);

  }

 }

}

public class ThreadDemo3 {

 public static void main(String[] args) {

  ThreadToString tts = new ThreadToString();

  Thread t0 = new Thread(tts);

  Thread t1 = new Thread(tts);

  t0.setPriority(Thread.MAX_PRIORITY);

  t1.setPriority(Thread.NORM_PRIORITY);

  t0.start();

  t1.start();

 // System.out.println(t);

 }

}

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