多线程

多线程

  什么是线程?
 
  进程:可以简单理解成就是一个应用程序.

  多个线程组成了一个进程.

  进程与进程之间不可能进行通信，但是同一个进程中的线程可以进行通信.
 
  我们使用多线程 程序目的就是为了提高效率.

  多线程程序相当于拥有多条通路去执行。 

 JVM在启动时是单线程还是多线程的?
 
  JVM在启动时是多线程。一共启动了两个线程

  1.非守护线程  (其实就是我们的main方法，也叫做主线程)

  2.守护线程 (垃圾回收) 它的作用用来清理堆内存中存在的没有引用指向的对象
                       它调用就是finalize方法

创建线程的两种方式

1：第一种是继承 Thread类，重写run方法

2：第二种是 实现Runnable接口，重写run方法

代码实现：第一种继承 Thread类，重写run方法

/*
 当我们执行这段代码时，一共有两个线程 一个是main线程，另外一个是我们
 自定义的MyThread线程，我们管它叫子线程.
*/

class ThreadClass
{
 public static void main(String[] args)
 {
  MyThread mt=new MyThread();//创建线程对象

  mt.start(); //启动线程
  
  //mt.run(); //调用run方法

  for(int i=0;i<100;i++){
   
   System.out.println("main"+i);
  }

 }
}

/*
 自定义一个线程类
 步骤
 1.继承Thread
 2.重写run方法 
  通过查看帮助文档发现 Thread类中的run方法中没有任何内容，只是告诉我们子类要重写这个方法
 3.创建线程对象，并启动线程

 run方法作用: 要执行的子线程的内容。
 start作用:   启动线程  jvm重新开辟运行通信
*/

class MyThread extends Thread
{
 //重写run方法
 public void run(){
 
  for(int i=0;i<100;i++){
   
   System.out.println("run"+i);
  }
  //System.out.println("得写了从Thread类中继承的run");
 }

}
/*
 调用run方法与start方法区别

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

 run:使用run方法执行，main方法中调用的run。

*/

/*

多线程程序的无规则性

 根据这个程序的结果，发现main或run内容谁先执行，谁先执行多少个
 这个是规律的，这个叫多线程程序的无序性.

 为什么出现这种情况，是因为cpu在执行时，我们控制不了cpu的时间片
 分配，分配给哪一个线程，哪个线程就执行。

*/

代码实现：第二种实现Runnable接口，重写run方法

/* 创建线程的第二种方式

 2.实现Runnable接口
 Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。

  步骤
  1.创建类去实现Runnable接口
  2.Runnable接口中定义了一个run方法，必须重写
  3.启动线程  将实现了Runnable接口类的对象做为参数传递给Thread构造方法，
    这样在通过Thraed对象去调用start方法时，就知道应该执行哪个run。

    例如  new Thread(实现Runnable接口对象).start();

*/
class ThreadClass_2
{
 public static void main(String[] args)
 {
  Runnable mr=new MyRunnable();

  //mr.start(); 不行，因为Runnable接口中没有定义start方法

  //启动线程
  Thread th=new Thread(mr);
  th.start();
  //new Thread(mr).start();
  /*
   分析上面这句话
   1.new Thread(mr)  通过这句话是不是知道 Thread类中提供一个可以接收Runnable类型的构造方法
   2.通过帮助文档发现  参数的作用就是执行这个对象所对应的run方法
  */
  

 }
}

 

class MyRunnable implements Runnable
{
 //重写接口中的方法
 //使用实现接口 Runnable 的对象创建一个线程时，
 //启动该线程将导致在独立执行的线程中调用对象的 run 方法。
 public void run(){
  
  System.out.println("子线程执行的内容");
 }
}

两种创建方式的区别：

实现方式和继承方式有什么区别呢？

实现方式好处：避免了单继承的局限性。在定义线程时，建议使用实现方式。

两种方式区别：

继承Thread:线程代码存放Thread子类run方法中。

实现Runnable，线程代码存在接口的子类的run方法。

多线程程序的几种状态

/*
 多线程程序的几种状态

 1.创建状态
 2. start 启动 运行状态
 3.冻结
 4.销毁  1. 线程结束  run运行结束  2.调用stop()不建议使用
 5.临时堵塞状态

 

*/
class Demo7
{
 public static void main(String[] args)
 {
  ThreadDemo td=new ThreadDemo();

  Thread th1=new Thread(td);
  Thread th2=new Thread(td);
  
  th1.start(); //运行
   
  th2.start(); //运行
  //new Thread(td).start(); //运行

  //System.out.println("main  message");
 }
}

class ThreadDemo implements Runnable
{
 public void run(){
 
  /*
  System.out.println("hello"+Thread.currentThread().getName());
  
  try{
   Thread.sleep(10);  //冻结
  }catch(Exception e){
   
  }

  System.out.println("world"+Thread.currentThread().getName());
  */

  for(int i=0;i<100;i++){
   
    System.out.println(Thread.currentThread().getName());
  }
 }
}

同步代码块 synchronized

格式：

synchronized(对象)

{

需要被同步的代码

 

}

同步的前提：

1，必须要有两个或者两个以上的线程。

2，必须是多个线程使用同一个锁。

必须保证同步中只能有一个线程在运行。

好处：解决了多线程的安全问题。

弊端：多个线程需要判断锁，较为消耗资源，

同步函数：

将修饰符放在函数上；

例：public synchronized void show()

函数需要被对象调用。那么函数都有一个所属对象引用。就是this。所以同步函数使用的锁是this。

例：synchronized(this)

静态的同步方法，使用的锁是该方法所在类的字节码文件对象。 类名.class   该对象的类型是Class

例：synchronized(Ticket.class)

线程间通讯：

其实就是多个线程在操作同一个资源，但是操作的动作不同。

wait:  等待线程

notify(); 唤醒线程

notifyAll();唤醒所有线程

都使用在同步中，因为要对持有监视器(锁)的线程操作。所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义Object类中呢？

因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁，

只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。

不可以对不同锁中的线程进行唤醒。

也就是说，等待和唤醒必须是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。

JDK1.5新特性

import java.util.concurrent.locks.*;(导包)

JDK1.5 中提供了多线程升级解决方案。

将同步Synchronized替换成现实Lock操作。

将Object中的wait，notify notifyAll，替换了Condition对象。

该对象可以Lock锁 进行获取。

Lock:替代了Synchronized

lock 

unlock

newCondition()

Condition：替代了Object wait notify notifyAll

await();

signal();

signalAll();

如何停止线程？

只有一种，run方法结束。

开启多线程运行，运行代码通常是循环结构。

只要控制住循环，就可以让run方法结束，也就是线程结束。

interrupt强制将线程恢复到运行状态；

特殊情况：

当线程处于了冻结状态。

就不会读取到标记。那么线程就不会结束。

当没有指定的方式让冻结的线程恢复到运行状态是，这时需要对冻结进行清除。

强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。

Thread类提供该方法 interrupt();

join等待线程终止；强制夺取CPU执行权，致使当前线程运行完；

join:可以用来临时加入线程执行

当A线程执行到了B线程的.join()方法时，A就会等待。等B线程都执行完，A才会执行。。