java--多线程基础

进程:正在运行的程序,是系统进行资源分配和调用的独立单位,每一个进程都有它自己的内存空间和系统资源
 
多进程:在同一个时间段内执行多个任务
 
多线程的意义:多线程的存在,不是提高程序的执行速度,其实是为了提高应用程序的使用率(一个进程中更多的线程更容易抢到CPU资源,CPU执行权),就会使进程有更高的几率抢到CPU的执行权
 
注意:不能保证哪一个线程能够在哪一个时刻抢到,所以线程的执行有随机性
并行和并发的区别:
并行:逻辑上同时发生,指在某一个时间内同时发生
并发:物理上同时发生,指在某一个时间点运行多个程序
 
java程序运行原理:java命令会启动java虚拟机,启动JVM,等于启动一个应用程序,也就是启动了一个进行。该进程会自动启动一个“主线程”,然后主线程去调用某个类的main方法。所以main方法允许在主线程中。在此之前的程序都是运行在单线程中的。
问题:JVM虚拟机的启动是单线程还是多线程?
   JVM启动至少启动了垃圾回收线程和主线程,所以是多线程的
 
如何实现多线程的程序?
由于线程是依赖于进程而存在的,所以我们应该先创建一个进程出来。而进程是由系统创建的,所以我们应该调用系统功能创建一个进程。
java是不能直接调用系统功能的,所以,我们没有办法直接实现多线程程序。
但是java可以去调用C/C++写好的程序来实现多线程程序。即利用C/C++去调用系统功能创建进程,java对于这些C/C++的进程程序进行了封装,包装成一些类,这样就可以直接调用这些类去实现多线程程序。
 
java提供了Thread类中的run()用来包含哪些被线程执行的代码
 

 
主要内容:线程概述、多线程实现方案、线程调度和线程控制、线程生命周期、线程同步、死锁、线程间的通信、定时器的使用
 
多线程实现方案:基本是两种方式,还有一种作为扩展方式(实现Callable接口,依赖于线程池)
线程调度和控制:调度:设置线程的优先级    控制:线程的运行状态控制(具体涵盖:start/sleep/yield/join/...)
线程生命周期:创建、就绪、运行、阻塞、死亡(状态)
线程同步:防止多线程带来的安全问题
死锁:因多个不同种类的线程对同一个资源的抢占而产生的循环等待现象
线程间通信:java中的等待唤醒机制
 
1  实现多线程的方式:
方式一:继承Thread类
A:自定义类MyThread继承Thread类
B:在MyThread类中重写run( )方法
C:创建MyThread对象
D:启动线程对象
问题:
1、为什么要重写run( )方法?
     run()方法里封装的是被线程执行的代码
2、启动线程对象的方法?
     start()
3、run()和start()方法的区别?
     run()直接调用仅仅是普通方法
     start():先启动线程,再由JVM调用run( )方法
 
方式二:
A:自定义类MyRunnable实现Runnable接口
B:在MyRunnable里面重写run()方法
C:创建MyRunnable对象
D:创建Thread类的对象,并把C步骤的对象作为构造参数传递
 
问题:
1、方式1 方式2为什么有两种实现机制?
     方式二解决了单继承的局限性
     适合多个相同程序的代码去处理同一个资源的情况,把线程同程序的代码、数据有效分离,较好体现面向对象的设计思想
 
线程的状态转换:
 
 

线程的生命周期图:

2  线程的安全问题:
判断一个 程序是否有线程安全的标准?
1)是否有多线程环境
2)是否有共享数据
3)是否对共享数据进行操作
 
java提供了同步机制:
     格式:synchronized(对象){
                   需要同步的代码......
               }
     注意:同步问题可以解决的根本原因就在那个对象上,该对象如同锁的功能。
               多个线程要求必须是同一把锁。
 
同步解决线程安全问题:
A:同步代码块:
          synchronized(对象){
                   需要同步的代码......
          }
 
B:同步方法
把同步加在方法上
这里的锁对象是this
 
C: 静态同步方法
 把同步加在方法上
这里的锁对象是当前类的字节码文件对象(Class对象)

注意:当时在集合中提到,Vector是线程安全的类,但是即使在多线程条件下也不使用该类,这是因为什么呢?
主要是因为Collections这个集合工具类的存在:它有很多静态方法可以将一个其他不线程安全的集合例如ArrayList/LinkedList集合转成一个线程安全的集合:
例如:
     ArrayList<String> list1 = new ArrayList<String>( );    //线程不安全的ArrayList集合
     ArrayList<Stirng> list2 = Collections.synchronizedList(new ArrayList<String>( ));   //线程安全的ArrayList集合
 
Lock锁:
虽然可以理解同步代码块和同步方法的锁对象问题,但是我们并没有直接看到在哪里加上了锁,在哪里释放了锁,为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock
Lock接口:java.util.concurrent.locks.Lock
提供了两个方法:void  lock( )和void  unlock( )
其实现子类:
     ReentrantLock
 
格式:
ReentrantLock lock = new ReentrantLock( );//创建ReentrantLock对象
lock.lock( );  //加锁
     需要同步的代码;
lock.unlock( );//释放锁
 
通常考虑到同步的代码块出错的可能性,所以使用以下方式:
try{
     lock.lock( );
     需要同步的代码块...............
}finally{
     lock.unlock( );
}

同步锁的弊端:
1)效率低:安全
2)如果出现同步嵌套,就容易产生死锁问题:相互等待
死锁问题及其代码:
是指两个或者两个以上的线程在执行过程中,因争夺资源产生的一种相互等待的现象
同步嵌套代码的:最少两个锁
同步嵌套代码的举例:
Class myThread extends Thread{
     private boolean flag;
     private static final Object objA = new Object( );
     private static final Object objB = new Object( );
 
     public myThread( boolean flag ){
          this.flag = flag;
     }
     
     public void run( ){
          if(flag){
               synchronized(objA){
                   System.out.println("if ObjA"); 
                    synchronized(objB){
                         System.out.println("if ObjB");
                    }
               }
          }else{         
                synchronized(objB){
                   System.out.println("else ObjB"); 
                    synchronized(objA){
                         System.out.println("else ObjA");
                    }
               }
          }
 
     }
}
在线程测试类中,创建两个线程,给与不同的flag值
可能就会出现死锁现象

线程之间的通信问题:不同种类的线程间针对同一个资源的操作
生产者和消费者:
不同种类的线程在操作时需要加锁
不同种类的线程加同一把锁
正常消费者和生产者的思路:
A:生产者:先看是否有数据,有就等待,没有就生产,生产完之后通知消费者来消费
B:消费者:先看有没有数据,有就消费,没有就等待,通知生产者生产数据
 
为了处理这样的问题,java就提供了一种机制:等待唤醒机制 保证一人一次
Object类中提供的方法:
1)wait( ):等待,该方法的特点是:一旦等待就释放锁,并且一旦被唤醒,就是在哪里开始等待的就从哪里开始继续
2)notify( ):唤醒单个线程。 被唤醒并不代表你可以立刻执行,还得去抢CPU执行权
3)notifyAll( ):唤醒相关的所有线程
问题:
 为什么这些方法不定义在Thread类中呢??
因为这些方法的调用必须通过锁对象调用,而我们刚才使用的锁对象是任意锁对象,所以这些方法必须定义在Object中。

 
线程组:ThreadGroup,java.lang.ThreadGroup
线程默认情况下都属于main线程组
如何修改线程所在的组???
1)创建一个线程组
2)创建线程的时候,把其他线程的组指定为新建的线程租
 
ThreadGroup tg = new ThreadGroup("producerThreadGroup");//创建一个线程组
Thread t1 = new Thread(tg,runnable,"thread1");                        //创建一个线程对象1,其所属的线程组是新创建的
Thread t2 = new Thread(tg,runnable,"thread2");                        //创建一个线程对象2,其所属的线程组是新创建的
//现在改线程组就包含了两个线程
 
但是线程组出现的意义在哪里呢???
可以实现统一管理整个线程组中所有的线程,
例如通过设置该组的线程优先级:tg.setMaxPriority( );可以使组内的所有线程都是最高优先级
 

线程池:
程序启动一个新线程成本是比较高的,因为它涉及到与操作系统进行交互,而使用线程池可以很好的提高性能,尤其是当程序中要创建大量生存周期很短的线程时,更应该考虑使用线程池
线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲 状态。等待下一个对象来使用。
在JDK5之前,我们必须手动实现自己的线程池,从JDK5开始,java内置支持线程池
 
位于:java.util.concurrent.Executors
JDK5新增了一个Executors工厂类来产生线程池,有如下几个方法:
  • public  static  ExecutorService  newCachedThreadPool( )    //并没有指定创建几个线程
  • public  static  ExecutorService  newFixedThreadPool( int  nThreads ) //可以指定在线程池放几个线程
  • public  static  ExecutorService  newSingleThreadExecutor( )             //该方法就是nThreads=1的情况下
这些方法的返回值都是ExecutorService接口(实现的父接口:Executor)对象,该对象表示一个线程池,可以执行Runnable对象或者Callable对象代表的线程。它提供了如下的方法:
  • Future<?>  submit( Runnable  task )
  • <T> Future<T>  submit( Callable<T>  task)
例如:
1)创建线程池对象:控制要创建几个线程对象
2)创建Runnable实例(创建一个实现Runnable接口或者Callable接口的类)
3)提交Runnable实例
4)关闭线程池(如果在使用线程后想关掉线程池,使用shutdown( )方法)
 
例如:
1)创建一个实现Runnable接口的类
public class MyRunnable implements Runnable {  
     @Override
     public void run() {
           for( int i=0; i<50; i++){
               System. out.println(Thread. currentThread().getName()+":"+i);
          }
     }
}
2)创建测试类
public class ThreadPoolDemo {
     public static void main(String[] args) {
           //newFixedThreadPool()返回的是ThreadPoolExecutor:ExecutorService的子类
          ExecutorService pool = Executors.newFixedThreadPool(3);//在线程池中创建三个线程
           pool.submit( new MyRunnable()); //启动线程
           pool.submit( new MyRunnable()); //启动线程
 
           pool.shutdown(); //启动一次顺序关闭,执行以前提交的任务,但不接受新任务。
     }
}
 
在之前提到创建线程的方式:
1)继承Thread类
2)实现Runnable接口
而在线程池中有一种实现Callable接口创建线程的方式,但是这种方式只能依赖线程池,该接口有个特点,线程运行后有返回值。
而其他两种方式中的run( )方法的返回值是void。这也是该种方法的特点所在。
 
3)实现Callable接口
使用的好处:可以有返回值,可以抛出异常(而在run方法中的异常只能try----catch处理)
弊端:代码复杂,一般不用
 

匿名内部类实现多线程:

第一种方式:
new Thread(){
               @Override
               public void run() {
                    for( int i=1; i<50; i++){
                        System. out.println(Thread. currentThread().getName()+"----"+i);
                   }
              }
          }.start();

第二种方式
new Thread(new Runnable(){
               @Override
               public void run() {
                    for( int i=1; i<50; i++){
                        System. out.println( "java"+ "----"+ i);
                   }
              }
          }).start();

第三种方式:开发中不会出现,但是在一般面试时会遇到:
1)该方式会报错吗?  不会
2)线程会执行哪段代码?  会执行 new Thread中{ }中的代码,即下面用红色标注的部分有效
new Thread(new Runnable(){
               @Override
               public void run() {
                    for( int i=1; i<50; i++){
                        System. out.println(Thread. currentThread().getName()+"----"+i);
                   }
              }
          }){
              @Override
              public void run() {
                    for( int i=1; i<50; i++){
                        System. out.println( "hello"+ "----"+ i);
                   }
              }
          }.start();

定时器:
在java中可以通过Timer和TimerTask类来实现定义调度的功能
 
Timer:  java.util.Timer(具体类)
  • public  Timer( )
  • public void schedule( TimerTask  task, long  delay)
  • public void schedule( TimerTask  task, long  delay,long  period)
 
TimerTask:java.util.TimerTask(抽象类),实现了Runnable接口
  • public abstract void run( )
  • public boolean cancel( )
 
开发中,Quariz是一个完全由java编写的开源调度框架
 

多线程相关的问题:
1、多线程有几种实现方案,分别有哪几种?
     实现方式有两种:
          1)继承Thread类:
          2)实现Runnable接口
     
2、同步有几种方式,分别是什么?
     有两种方式。
     1)同步块的方式          (锁的是任意对象)
     2)同步方法的方式   (锁的是当前类对象)
 
3、启动一个线程是run( )还是start( )?他们的区别是?
     启动线程用start( )。
     run方法封装了线程执行的代码,直接调用仅仅是普通方法的调用
     start方法启动线程,并由JVM自动调用run方法
 
4、sleep( )和wait( )方法的区别?(sleep是在Thread类中定义的,而wait方法定义在Object类)
     首先:sleep方法必须指定时间,而wait可以指定时间也可以不指定时间
     其二:sleep方法在线程休眠期间不释放资源(锁),而wait方法在进入等待状态时释放自己持有的锁。
 
5、为什么wait( ) notify( ) notifyAll( )等方法都定义在Object类中?
     因为wait notify notifyAll等方法的调用依赖于锁对象,而同步代码块的锁对象是任意锁。
     由因为Object对象代表是任意一个对象,所以这些方法的定义必须在Object类中

银联笔试看到这样一道题:
class NewThread extends Thread implements Runnable(){
   public void run(){
    System.out.println("run()");
  }
}
 
class Demo{
  public static void main(String[] args){
    Thread t1 = new Thread(new NewThread());
    t1.start();
  }
}
试问这道题会正常运行吗?如果不能运行,会在第几行报错?
 经过测试这是可以的,NewThread 既继承了Thread又实现了Runnable接口,new NewThread()就可以看成一个Thread或者一个Runable接口的实现类,在测试类中
 Thread t1 = new Thread(new NewThread());Thread构造函数的参数是一个实现Runnable接口的实现类,而NewThread类正好实现类Runnable接口,故可以当做参数传入。
 
 
posted @ 2016-09-24 11:15  zwbg  阅读(280)  评论(0编辑  收藏  举报