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

java并发编程之美-阅读记录1

时间:2019-08-09 01:24:09      阅读:89      评论:0      收藏:0      [点我收藏+]

标签:共享   信号   中断   守护   随机   程序   一个   ring   result   

1.1什么是线程?

  在理解线程之前先要明白什么是进程,因为线程是进程中的一个实体。(线程是不会独立存在的)

  进程:是代码在数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,线程则是进程中的一个执行路径,一个进程中至少会有一个线程,进程中的多个线程共享进程的资源。

  线程:是cpu分配的基本单位。

  技术图片

  由上图可看出,一个进程中会有多个线程,多个线程共享堆和方法区,但是每一个线程都会有自己的栈和程序计数器。

为什么要将栈和程序计数器设置为线程私有的呢?
    前边说线程是cpu执行的基本单位,而cpu一般是使用时间片轮转方式轮询占用的,所以当当前线程cpu时间片使用完毕后,要让出cpu,等待下一次轮到自己的时候在调用。
那问题就来了,线程是如何知道之前执行到哪了?
    程序计数器就是为了记录之前让出cpu时执行到的地址,等下次再次执行时就可以从程序计数器中获取之前执行到的位置,继续向下执行。(程序计数器是不会记录native方法执行的地址的,它只记录java代码执行的地址),而栈则是存储现场的局部变量,一遍之后再次使用

 

1.2线程的创建和运行

  三种方式:继承Thread、实现Runnable接口、使用FuthreTask方式(实现Callable接口)。

package com.nxz.blog.otherTest;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class TestThread {

    static class MyThread1 extends Thread {
        @Override
        public void run() {
            System.out.println("extend-Thread:"+this.getName());
        }
    }

    static class MyThread2 implements Runnable {

        @Override
        public void run() {
            System.out.println("implements-Runnable:"+Thread.currentThread());
        }
    }

    static class MyThread3 implements Callable<String> {

        @Override
        public String call() throws Exception {

            System.out.println("implements-Callable:"+Thread.currentThread());
            return "Callable接口";
        }
    }


    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        t1.start();

        Thread t2 = new Thread(new MyThread2());
        t2.start();

        FutureTask<String> futureTask = new FutureTask<>(new MyThread3());
        new Thread(futureTask).start();
        try {
            // 阻塞,等待执行完毕,并返回结果
            String res = futureTask.get();
            System.out.println(res);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println("main-Thread");
    }
}

  上述代码执行结果:

extend-Thread:Thread-0
implements-Runnable:Thread[Thread-1,5,main]
implements-Callable:Thread[Thread-2,5,main]
Callable接口
main-Thread

  创建线程后会调用start方法,代表当前线程已经处于就绪状态(也就是说该线程已经获取了除cpu资源外的其他资源,等待cpu执行时间片),当获取了cpu资源后,该线程才处于运行状态,一旦run方法(对于extent Thread来说)执行完毕,该线程就处于终止状态。

  使用继承的好处:在run方法内可以直接使用this来获取当前线程(而另两个的this则没有getName等一些方法),而不需要Thread.currentThread()。

1.3线程通知和等待

  以下三个方法都是Object类的方法,为所有对象公用

  ①wait()

    当一个线程调用wait()方法后,该线程就会被阻塞挂起,知道被notify/notifyAll调用或者其他线程调用了intercept方法中断了该线程

  ②wait(long timeout)

    表上边一个多了一个超时时间,在等待期间如果没有其他线程唤醒(notify/notifyAll)该线程,该线程仍然会在超过timeout时间后自动返回

  ③wait(long timeout, int nanos)  :两个参数,毫秒timeout,纳秒nanos,其内部还是调用的wait(long timeout)方法,只不多对于第二个参数纳秒,如果其范围是大于0,小于一百万的话(1毫秒= 100 0000纳秒),则将timeout加一秒

    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }
        if (nanos > 0) {
            timeout++;
        }
        wait(timeout);
    }

  ④notify()/notifyAll()

    唤醒在同一个共享变量上等待的线程,区别:一个唤醒一个,一个唤醒所有

  需要注意的:

  *虚假唤醒:

    一个线程可以从挂起状态变为可以运行状态(也就是被唤醒),即使该线程没有被其他线程调用notify()、notifyAll()方法进行通知,或者被中断,或者等待超时,这就是虚假唤醒

  (在java并发编程之美中这样描述的,感觉不太清楚,找了其他资料有的是这样描述的:在多核处理器下,其他线程的信号可能会唤醒多个线程(阻塞在同一个条件变量上的线程),结果就是,多个被唤醒的线程,前一个执行代码逻辑后,另外的线程再次执行同样的代码后会出现问题)

    例子:在下边代码中分别为生产者和消费者,假如在一个生产者和一个消费者的情况下(也就是单线程),是没有问题的,不存在虚假唤醒,假如在多线程环境下,当一个生产者完成之后,调用notifyAll方法后,会唤醒其他生产者和所有的消费者,当第一个消费者消费完成之后,在有消费者消费,此时就会出现问题(也就是出现了虚假唤醒),解决该问题的方法,就是将消费者和生产者中的条件判断if(queue.size() == 1) 和if(queue.isEmpty()) 改为   while( queue.size() == 1) 和while( queue.isEmpty() ) ,即改为循环判断,当被唤醒是,每一个线程都重新判断是否符合条件

    static Queue queue;

    static class ProductThread extends Thread {
        @Override
        public void run() {
            synchronized (queue) {
                if (queue.size() == 1) {// 假设队列最多存一个对象
                    try {
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                queue.add(new Object());
                queue.notifyAll();
            }
        }
    }

    static class ConsumerThread extends Thread {
        @Override
        public void run() {

            synchronized (queue) {
                if (queue.isEmpty()) {
                    try {
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                queue.poll();
                queue.notifyAll();
            }
        }
    }

 

1.4等待线程执行完毕   的join方法

  当调用join方法(该方法属于Thread类)时,就会等待线程执行完毕后,在继续向下运行

  例子:

package com.nxz.blog.otherTest;

public class TestThread002 {

    static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println("myThread");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread();
        t1.setName("myThread");
        t1.start();

        // 如果注释掉 下边代码的话,main方法的输出应该会是  先main-thread 然后再试mythread,
        // 放开的话 main主线程就会等待t1线程执行完毕后,在向下运行
        t1.join();

        System.out.println("main-thread");
    }
}

 

1.5sleep方法休眠

  Thread中的静态方法sleep(),当一个线程调用了sleep方法后,会短暂的让出cpu执行权(也就是不参与cpu的调度),但是线程拥有的锁等资源是不释放的,这一点和wait方法不同

1.6让出cpu执行权yield方法

  Thread中的静态方法yield(),当一个线程调用了Thread.yield()时,表名当前线程放弃cpu的使用权,yield之后,当前线程处于就绪状态。线程调度器会从包括该线程的所有线程中随机选出一个线程分配cpu执行时间片。

1.7中断线程

  java中的线程中断是一种线程间的协作模式,通过设置线程的中断标志并不能直接中断线程,而是被中断的线程根据中断标志自行处理。

  void interruupt() :中断线程

  boolean isInterrupted() :检测当前现车鞥是否中断(调用isInterrupted()方法的实例的中断标志)

  boolean interrupted(): 检测当前线程是否被中断(内部是获取当前线程的中断标志而不是调用interruupted()方法的实例的中断标志)

 1.8线程的上下文切换

  在多线程编程中线程的个数一般都是大于cpu的个数的,而每个cpu在同一时刻只能被一个线程使用。为了让用户感觉实在同时执行,cpu资源的分配采用时间片轮询的侧率。

  上下文切换:就是一个线程使用完时间片之后,将cpu资源让给其他线程使用,并且线程状态转变为就绪状态。

1.9线程死锁

  多个线程在执行过程中,因争夺资源而造成相互等待的状态,如没有其他因素,线程会一直等待,而无法继续运行。

  死锁产生的条件:1、互斥 2、请求并持有资源 3、不可剥夺 4、环路等待

1.10守护线程和用户线程

  守护线程:类似垃圾回收线程

  用户线程:main函数启动,就是一个简单的用户线程

  jvm停止的时机:在用户线程全都执行完毕后,jvm就会停止(无论有没有守护线程)

1.11ThreadLocal

  当创建了一个ThreadLocal变量之后,多个线程操作这个变量时,实际上操作的是自己本地内存里的变量,也就是说每个线程都会复制一份变量到自己的本地内存。

  THreadLocal是怎么和线程关联起来的呢?

    ThreadLocal其实就是一个空壳,当调用ThreadLocal的set或get方法时,其内部是通过set方法把value放到调用线程的threadlocals变量中(ThreadLocal.threadLocalMap),也就是说本地变量不是存在ThreadLocal实例中,而是存入Thread中的threadlocals中。

    public void set(T value) {
        Thread t = Thread.currentThread();
     // 当调用ThreadLocal的set方法时,其实是获取的是当前线程Thread中的ThreadLocalMap变量,如果变量为null,则新建一个ThreadLocalMap,如果变量存在,则之间将当前线程和value存入定制的map中(ThreadLocalMap) ThreadLocalMap map
= getMap(t); if (map != null) map.set(this, value); else createMap(t, value); }
  // 从源码getMap中可以看出,其实获取的是当前线程中的threadLocals变量 ThreadLocalMap getMap(Thread t) {
return t.threadLocals; } void createMap(Thread t, T firstValue) { t.threadLocals = new ThreadLocalMap(this, firstValue); }
    public T get() {
     // ThreadLocal的get方法,同样是获取的是当前线程Thread中的threadLocals变量(也就是ThreadLocalMap类型的数据) Thread t
= Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) { ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) { @SuppressWarnings("unchecked") T result = (T)e.value; return result; } } return setInitialValue(); }

 

  

 

    

java并发编程之美-阅读记录1

标签:共享   信号   中断   守护   随机   程序   一个   ring   result   

原文地址:https://www.cnblogs.com/nxzblogs/p/11318671.html

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