JAVA基础知识点（十一）--线程

进程: 进程就是正在运行的应用程序。进程了负责了内存空间划分。

线程：一个进程中的 代码是由线程去执行的，线程也就是进程中一个执行路径。

多线程：一个进程中有多个线程可以同时执行任务。

多线程的好处：

         1.解决一个进程中可以同时执行多个任务的问题。

         2.提高了资源利用率。

多线程的弊端：

         1.增加了cpu的负担。

         2.降低了一个进程中线程的执行概率。

         3.出现了线程 安全问题。

         4.会引发死锁现象。

        

一、自定义线程的实现方式：

         方式一 ：

                  1.自定义一个类继承Thread类。

                  2.重写Thread类的run方法，把自定义线程的任务代码写在run方法上。

                  3.创建Thread的子类对象，并且调用start方法启动一个线程。

         注意：千万不要直接调用run方法，调用start方法的时候线程就会开启，线程一旦开启就会执行run方法中代码，如果直接调用run方法，那么就相当于调用了一个普通的方法而已。

 

方式二：

         1.自定义一个类实现Runnable接口。

         2.实现Runnable接口的run方法，把自定义线程的任务定义在run方法上。

         3.创建Runnable实现类对象。

         4.创建Thread类的对象，并且把Runnable实现类的对象作为实参传递。

         5.调用Thread对象的start方法开启一个线程。

 

问题1：请问Runnable实现类的对象是线程对象吗？

         Runnable实现类的对象并 不是一个线程对象，只不过是实现了Runnable接口的对象而已。只有是Thread或者是Thread的子类才是线程对象。

问题2：为什么要把Runnable实现类的对象作为实参传递给Thread对象呢？作用是什么？

         作用就是把Runnable实现类的对象的run方法作为了线程的任务代码去执行了。

 

推荐使用：第二种。 实现Runable接口的。

原因：因为java单继承 ,多实现的。

public class Demo3 implements Runnable{

         publicvoid run() {

                  /*System.out.println("this："+this);

                  System.out.println("当前线程："+Thread.currentThread());*/

                  for(inti = 0 ; i < 100 ; i++){

                          System.out.println(Thread.currentThread().getName()+":"+i);

                  }

         }

        

         publicstatic void main(String[] args) {

                  //创建Runnable实现类的对象

                  Demo3d = new Demo3();

                  //创建Thread类的对象， 把Runnable实现类对象作为实参传递。

                  Threadthread = new Thread(d,"狗娃");  //Thread类使用Target变量记录了d对象，

                  //调用thread对象的start方法开启线程。

                  thread.start();

                 

                  for(inti = 0 ; i < 100 ; i++){

                          System.out.println(Thread.currentThread().getName()+":"+i);

                  }

                 

         }

             public void run() {

                 if (target != null) {

                     target.run();  //就相当于Runnable实现类的对象的run方法作为了Thread对象的任务代码了。

                 }

             }

}

 

二、线程安全问题：

 线程安全出现的根本原因：

         1.存在两个或者两个以上的线程对象共享同一个资源。

         2.多线程操作共享资源的代码有多句。

线程安全问题的解决方案：

         方式一： 可以使用同步代码块去解决。

         格式：

                  synchronized(锁对象){

                          需要被同步的代码

                  }

        

同步代码块要注意的事项：

         1.锁对象可以是任意的一个对象。

         2.一个线程在同步代码块中sleep了，并不会释放锁对象。

         3.如果不存在着线程安全问题，千万不要使用同步代码块，因为会降低效率。

         4.锁对象必须是多线程共享的一个资源，否则锁不住。

        

         方式二：同步函数  ：  同步函数就是使用synchronized修饰一个函数。

         同步函数要注意的事项 ：

                  1.如果是一个非静态的同步函数的锁对象是this对象，如果是静态的同步函数的锁对象是当前函数所属的类的字节码文件（class对象）。

                  2.同步函数的锁对象是固定的，不能由你来指定的。

 

推荐使用同步代码块。原因：

1. 同步代码块的锁对象可以由我们随意指定，方便控制。同步函数的锁对象是固定 的，不能由我们来指定。

2. 同步代码块可以很方便控制需要被同步代码的范围，同步函数必须是整个函数 的所有代码都被同步了。

 

 三、死锁

java中同步机制解决了线程安全问题，但是也同时引发死锁现象。

死锁现象出现的根本原因：

         1.存在两个或者两个以上的线程。

         2.存在两个或者两个以上的共享资源。      

死锁现象的解决方案：没有方案。只能尽量避免发生而已。

四、线程通讯

线程通讯：一个线程完成了自己的任务时，要通知另外一个线程去完成另外一个任务.

wait(): 等待   如果线程执行了wait方法，那么该线程会进入等待的状态，等待状态下的线程必须要被其他线程调用notify方法才能唤醒。

notify()： 唤醒    唤醒线程池等待线程其中的一个。

notifyAll() : 唤醒线程池所有等待 线程。

 

wait与notify方法要注意的事项：

         1.wait方法与notify方法是属于Object对象的。

         2.wait方法与notify方法必须要在同步代码块或者是同步函数中才能使用。

         3.wait方法与notify方法必需要由锁对象调用。

        

生产者与消费者

//产品类

class Product{

         Stringname;  //名字

         doubleprice;  //价格

         booleanflag = false; //产品是否生产完毕的标识，默认情况是没有生产完成。

}

//生产者

class Producer extends Thread{

         Product  p ;         //产品

         publicProducer(Product p) {

                  this.p  = p ;

         }

         publicvoid run() {

                  inti = 0 ;

                  while(true){

                   synchronized (p) {

                          if(p.flag==false){

                                    if(i%2==0){

                                             p.name = "苹果";

                                             p.price = 6.5;

                                    }else{

                                             p.name="香蕉";

                                             p.price = 2.0;

                                    }

                                    System.out.println("生产者生产出了："+p.name+" 价格是："+ p.price);

                                    p.flag = true;

                                    i++;

                                    p.notifyAll(); //唤醒消费者去消费

                          }else{

                                   //已经生产 完毕，等待消费者先去消费

                                   try{

                                            p.wait();   //生产者等待

                                   }catch (InterruptedException e) {

                                            e.printStackTrace();

                                   }

                          }

                  }      

           }  

         }

}

//消费者

class Customer extends Thread{

         Productp;

         public  Customer(Product p) {

                  this.p= p;

         }

         publicvoid run() {

                  while(true){

                          synchronized(p) {  

                                   if(p.flag==true){  //产品已经生产完毕

                                            System.out.println("消费者消费了"+p.name+"价格："+ p.price);

                                            p.flag= false;

                                            p.notifyAll();// 唤醒生产者去生产

                                   }else{

                                            //产品还没有生产,应该 等待生产者先生产。

                                            try{

                                                     p.wait();//消费者也等待了...

                                            }catch (InterruptedException e) {

                                                     e.printStackTrace();

                                            }

                                   }

                          }

                  }      

         }

}

public class Demo5 {

         publicstatic void main(String[] args) {

                  Productp = new Product();  //产品

                  //创建生产对象

                  Producerproducer = new Producer(p);

                  //创建消费者

                  Customercustomer = new Customer(p);

                  //调用start方法开启线程

                  producer.start();

                  customer.start();

         }

}

 五、线程的停止

        1. 停止一个线程 我们一般都会通过一个变量去控制的。

        2. 如果需要停止一个处于等待状态下的线程，那么我们需要通过变量配合notify方法或者interrupt()来使用。

public class Demo6 extends Thread {

         booleanflag = true;

         publicDemo6(String name){

                  super(name);

         }

         publicsynchronized void run() {

                  inti = 0 ;

                  while(flag){

                          try{

                                   this.wait();//狗娃等待..

                          }catch (InterruptedException e) {

                                   System.out.println("接收到了异常了....");

                          }

                          System.out.println(Thread.currentThread().getName()+":"+i);

                          i++;

                  }

         }

         publicstatic void main(String[] args) {

                  Demo6d = new Demo6("狗娃");

                  d.setPriority(10);

                  d.start();

                  for(inti = 0 ; i<100 ; i++){

                          System.out.println(Thread.currentThread().getName()+":"+i);

                          //当主线程的i是80的时候停止狗娃线程。

                          //d.interrupt();  // interrupt()根本就是无法停止一个线程。

                          if(i==80){

                                   d.flag= false;

                                   d.interrupt();//把线程的等待状态强制清除，被清除状态的线程会接收到一个InterruptedException。

                                   /*synchronized(d) {                                          

                                            d.notify();

                                   }*/

                          }

                  }

         }

}

六、守护线程（后台线程）

在一个进程中如果只剩下了守护线程，那么守护线程也会死亡。

 需求： 模拟QQ下载更新包。

 一个线程默认都不是守护线程。

public class Demo7 extends Thread {

         publicDemo7(String name){

                  super(name);

         }

         publicvoid run() {

                  for(inti = 1 ; i<=100 ; i++){

                          System.out.println("更新包目前下载"+i+"%");

                          if(i==100){

                                   System.out.println("更新包下载完毕,准备安装..");

                          }

                          try{

                                   Thread.sleep(100);

                          }catch (InterruptedException e) {

                                   e.printStackTrace();

                          }

                  }

         }

        

         publicstatic void main(String[] args) {

                   Demo7 d = new Demo7("后台线程");

                   d.setDaemon(true); //setDaemon() 设置线程是否为守护线程，true为守护线程， false为非守护线程。

                  //System.out.println("是守护线程吗？"+ d.isDaemon()); //判断线程是否为守护线程。

                   d.start();

                   for(int i = 1 ; i<=100 ; i++){

                           System.out.println(Thread.currentThread().getName()+":"+i);

                   }

         }

}

七、join方法：加入

//老妈

class Mon extends Thread{

         publicvoid run() {

                  System.out.println("妈妈洗菜");

                  System.out.println("妈妈切菜");

                  System.out.println("妈妈准备炒菜，发现没有酱油了..");

                  //叫儿子去打酱油

                  Sons= new Son();

                  s.start();

                  try{

                          s.join();  //加入。 一个线程如果执行join语句，那么就有新的线程加入，执行该语句的线程必须要让步给新加入的线程先完成任务，然后才能继续执行。

                  }catch (InterruptedException e) {

                          e.printStackTrace();

                  }

                  System.out.println("妈妈继续炒菜");

                  System.out.println("全家一起吃饭..");                

         }

}

 

class Son extends Thread{

         publicvoid run() {

                  System.out.println("儿子下楼..");

                  try{

                          Thread.sleep(1000);

                  }catch (InterruptedException e) {

                          e.printStackTrace();

                  }

                  System.out.println("儿子一直往前走");

                  System.out.println("儿子打完酱油了");

                  System.out.println("上楼，把酱油给老妈");

         }

}

 

public class Demo8 {

         publicstatic void main(String[] args) {

                  Monm = new Mon();

                  m.start();

                 

         }

}