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

java面试之多线程

时间:2020-03-14 11:21:04      阅读:73      评论:0      收藏:0      [点我收藏+]

标签:rmi   policy   处理器   mit   locking   clear   方法区   不同的   nal   

一、线程和进程之间的区别

1.进程:一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间,一个进程可以有多个线程,比如在Windows系统中,一个运行的xx.exe就是一个进程。
进程中的一个执行任务(控制单元),负责当前进程中程序的执行。一个进程至少有一个线程,一个进程可以运行多个线程,多个线程可共享数据。

2.线程:与进程不同的是同类的多个线程共享进程的堆和方法区资源,但每个线程有自己的程序计数器、虚拟机栈和本地方法栈,所以系统在产生一个线程,或是在各个线程之间作切换工作时,负担要比进程小得多,也正因为如此,线程也被称为轻量级进程。

3.区别

  • 根本区别:进程是操作系统资源分配的基本单位,而线程是处理器任务调度和执行的基本单位
  • 资源开销:每个进程都有独立的代码和数据空间(程序上下文),程序之间的切换会有较大的开销;线程可以看做轻量级的进程,同一类线程共享代码和数据空间,每个线程都有自己独立的运行栈和程序计数器(PC),线程之间切换的开销小。
  • 包含关系:如果一个进程内有多个线程,则执行过程不是一条线的,而是多条线(线程)共同完成的;线程是进程的一部分,所以线程也被称为轻权进程或者轻量级进程。
  • 内存分配:同一进程的线程共享本进程的地址空间和资源,而进程之间的地址空间和资源是相互独立的
  • 影响关系:一个进程崩溃后,在保护模式下不会对其他进程产生影响,但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。
  • 执行过程:每个独立的进程有程序运行的入口、顺序执行序列和程序出口。但是线程不能独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制,两者均可并发执行

    二、实现方式

  1. 继承Thread类:
/**
 * 线程的实现方式一:继承Thread类
 */

public class ThreadTest {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());

        Thread1 thread1 = new Thread1();
        Thread2 thread2 = new Thread2();

        thread1.start();
        thread2.start();
    }

}
class Thread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName());
        }
    }
}
class Thread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName());
        }
    }
}

2.实现Runable接口:

/**
 * 线程的实现方式二:实现Runable接口
 */
public class ThreadTest2 {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());

        Thread thread3 = new Thread(new Thread3());
        Thread thread4 = new Thread(new Thread4());

        thread3.start();
        thread4.start();
    }
}

class Thread3 implements Runnable{
    @Override
    public void run() {
            for (int i = 0; i < 10; i++){
                System.out.println(Thread.currentThread().getName());
            }
        }
}
class Thread4 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName());
        }
    }
}

两种实现方式的共同点和区别:

  • 共同点:将希望线程执行的代码块放入run()中,然后调用start()来启动
  • 区别:使用继承Thread类,类是唯一继承的原则那么该类就不能继承其他的类;而使用Runable接口的话在jiava中是可以实现的多个接口的,所以综上所述推荐使用Runable接口

    三、start()和run()之间的区别

  • run()方法本身就是一个普通的方法其所有的代码块都运行在主线程中
public void run() {

    if (target != null) {

        target.run();

    }

}
//target是一个Runnable对象。run()就是直接调用Thread线程的Runnable成员的run()方法,并不会新建一个线程。
  • start()方法线程运行在各自的线程中在调用时会创建一个新的线程并启动
public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

    private native void start0();//查看open jdk

四、主线程中获取

  1. 等待主线程完成后获取:
while (threadTest3.value == null){
            Thread.sleep(5000);
        }
  1. 使用join方法
thread.join();

 /**
     * Waits at most {@code millis} milliseconds for this thread to
     * die. A timeout of {@code 0} means to wait forever.
     *
     * <p> This implementation uses a loop of {@code this.wait} calls
     * conditioned on {@code this.isAlive}. As a thread terminates the
     * {@code this.notifyAll} method is invoked. It is recommended that
     * applications not use {@code wait}, {@code notify}, or
     * {@code notifyAll} on {@code Thread} instances.
     *
     * @param  millis
     *         the time to wait in milliseconds
     *
     * @throws  IllegalArgumentException
     *          if the value of {@code millis} is negative
     *
     * @throws  InterruptedException
     *          if any thread has interrupted the current thread. The
     *          <i>interrupted status</i> of the current thread is
     *          cleared when this exception is thrown.
     */
    public final synchronized void join(long millis)
    //从上述描述中我们可以得知join方法会一直到线程死掉

3.实现Callable接口


public class CallableTest implements Callable {
    @Override
    public Object call() throws Exception {
        String value = "我是返回值";

        System.out.println("开始执行业务逻辑");
        Thread.sleep(5000);
        System.out.println("执行业务逻辑完毕");

        return value;
    }
}
/**
 * Callabel接口实现:使用FutureTask
 */
public class CallableImk {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<String>(new CallableTest());
        new Thread(futureTask).start();

        if(!futureTask.isDone()){
            System.out.println("任务还没有完成,请稍等");
        }
        System.out.println(futureTask.get());
    }
}

4.使用线程池的方式:

public  class ThreadTest4 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        Future<String> future = executorService.submit(new CallableTest());
        if(!future.isDone()){
            System.out.println("waiting");
        }
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }finally {
            executorService.shutdown();
        }

    }
}

五、线程池

1.线程池的创建:

public class ThreadPoolExecutor extends AbstractExecutorService {
    .....
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
        BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);
    ...
}

参数说明:

  • corePoolSize:核心池的大小,这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后,默认情况下,线程池中并没有任何线程,而是等待有任务到来才创建线程去执行任务,除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法,从这2个方法的名字就可以看出,是预创建线程的意思,即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下,在创建了线程池后,线程池中的线程数为0,当有任务来之后,就会创建一个线程去执行任务,当线程池中的线程数目达到corePoolSize后,就会把到达的任务放到缓存队列当中;
  • maximumPoolSize:线程池最大线程数,这个参数也是一个非常重要的参数,它表示在线程池中最多能创建多少个线程;
  • keepAliveTime:表示线程没有任务执行时最多保持多久时间会终止。默认情况下,只有当线程池中的线程数大于corePoolSize时,keepAliveTime才会起作用,直到线程池中的线程数不大于corePoolSize,即当线程池中的线程数大于corePoolSize时,如果一个线程空闲的时间达到keepAliveTime,则会终止,直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法,在线程池中的线程数不大于corePoolSize时,keepAliveTime参数也会起作用,直到线程池中的线程数为0;
  • unit:参数keepAliveTime的时间单位,有7种取值,在TimeUnit类中有7种静态属性:
TimeUnit.DAYS;               //天
TimeUnit.HOURS;             //小时
TimeUnit.MINUTES;           //分钟
TimeUnit.SECONDS;           //秒
TimeUnit.MILLISECONDS;      //毫秒
TimeUnit.MICROSECONDS;      //微妙
TimeUnit.NANOSECONDS;       //纳秒

-workQueue:一个阻塞队列,用来存储等待执行的任务,这个参数的选择也很重要,会对线程池的运行过程产生重大影响,一般来说,这里的阻塞队列有以下几种选择:

ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue;

注意:ArrayBlockingQueue和PriorityBlockingQueue使用较少,一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。

  • threadFactory:线程工厂,主要用来创建线程;
  • handler:表示当拒绝处理任务时的策略,有以下四种取值:
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 
ThreadPoolExecutor.DiscardPolicy:也是丢弃任务,但是不抛出异常。 
ThreadPoolExecutor.DiscardOldestPolicy:丢弃队列最前面的任务,然后重新尝试执行任务(重复此过程)
ThreadPoolExecutor.CallerRunsPolicy:由调用线程处理该任务 

六、线程同步:
1.使用syncronized关键字:使用syncronized关键字修饰的方法是对对象的加锁;也可以修饰静态方法,当修饰静态方法是是对类加锁;也可以修饰代码块如下:

 synchronized(object){
    }
    //同步是一种高开销的操作,因此应该尽量减少//同步的内容。
    //通常没有必要同步整个方法,使用synchronized代码块同步关键代码即可。

注意:关于锁的话题,我们受限于篇幅下次再聊
七:生产者和消费者:

package Thread;


public class Person {

    private String name;
    private String sex;
    private boolean isEmpty = true;

    public  synchronized void set(String  name, String sex){
        while (!isEmpty){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.name = name;
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.sex = sex;
        System.out.println("生产者:" + name + sex);

        isEmpty = false;
        this.notifyAll();
    }

    public synchronized void get(){
        if (isEmpty){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("消费: " + getName() + getSex());
        isEmpty = true;
        this.notifyAll();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}
package Thread;

public class ProductConsumerTest {

    public static void main(String[] args) {
        Person person = new Person();
        new Thread(new Product(person)).start();
        new Thread(new Consumer(person)).start();
        new Thread(new Product(person)).start();
        new Thread(new Consumer(person)).start();
    }

}

class Product implements Runnable{
    private Person person;
    public Product(Person person){
        this.person = person;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++){
            if (i % 2 == 0){
                person.set("teacher", "man");
            }else {
                person.set("mother", "women");
            }
        }

    }
}
class Consumer implements Runnable{
    private Person person;
    public Consumer(Person person){
        this.person = person;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++){
            person.get();
        }
    }
}

参考资料:

"http://www.cnblogs.com/XHJT/p/3897440.html"

"https://www.cnblogs.com/dolphin0520/p/3932921.html"

java面试之多线程

标签:rmi   policy   处理器   mit   locking   clear   方法区   不同的   nal   

原文地址:https://www.cnblogs.com/yjfb/p/12490595.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!