java 面试资料库

昨天我整理了公众号历史所有和面试相关的我觉得还不错的文章:整理了一些有助于你拿Offer的文章 。今天分享一下最近逛Github看到了一些我觉得对于Java面试以及学习有帮助的仓库,这些仓库涉及Java核心知识点整理、Java常见面试题、算法、基础知识点比如网络和操作系统等等。

知识点相关

1.JavaGuide

2.CS-Notes

  • Github 地址:https://github.com/CyC2018/CS-Notes
  • Star: 68.3k
  • 介绍: 技术面试必备基础知识、Leetcode 题解、后端面试、Java 面试、春招、秋招、操作系统、计算机网络、系统设计。

3. advanced-java

  • Github地址:https://github.com/doocs/advanced-java
  • star: 23.4k
  • 介绍: 互联网 Java 工程师进阶知识完全扫盲:涵盖高并发、分布式、高可用、微服务等领域知识,后端同学必看,前端同学也可学习。

4.JCSprout

5.toBeTopJavaer

6.architect-awesome

7.technology-talk

  • Github地址: https://github.com/aalansehaiyang/technology-talk
  • star: 6.1k
  • 介绍: 汇总java生态圈常用技术框架、开源中间件,系统架构、项目管理、经典架构案例、数据库、常用三方库、线上运维等知识。

8.fullstack-tutorial

9.3y

10.java-bible

  • Github地址:https://github.com/biezhi/java-bible
  • star: 2.3k
  • 介绍: 这里记录了一些技术摘要,部分文章来自网络,本项目的目的力求分享精品技术干货,以Java为主。

11.interviews

算法相关

1.LeetCodeAnimation

2.awesome-java-leetcode

3.leetcode

关于谷歌极客Jeff Dean的冷笑话

在谷歌加州山景城总部,除了拉里·佩奇(Larry Page)和谢尔盖·布林(Sergey Brin),真正的牛人工程师要数杰夫·迪恩(Jeff Dean)了。

下面是谷歌员工 Heej Jones 在 Quora 上发布的关于Jeff Dean的一则故事:

来谷歌上班前一天,一个朋友给Jeff发邮件介绍了我,所以在上班的第一周,我就邀请他共进午餐。

那时候,我并不知道他是谁,也不了解他在谷歌的情况。只是午饭时,我有注意到其他餐桌的人在盯着他看,也有一些人路过我们的餐桌时会窃窃私语。

慢慢认识了更多的朋友,我才知道关于Jeff Dean的一些传奇故事;一位朋友曾经惊呼道:“你和Jeff Dean 一起吃过午饭?!”。

Jeff Dean

谷歌员工都认为谷歌搜索惊人的速度都归功于Jeff Dean,因此他也成了谷歌的名人。

大家对他的崇拜到底有多深?

你有听过关于武术战神查克·诺里斯的一些笑话吗?就像“查克从不洗盘子,盘子会因为恐惧他,自动清洗的”或者“查克被商业航班拒载,因为他的拳头会将飞机击落”等等诸如此类的笑话。

江湖中有一大堆关于Jeff Dean的传奇故事,都是由崇拜他的(前)谷歌员工写的。如果你了解软件工程师,懂得程序员幽默的话,那你会觉得那些故事非常有趣。

有时遇到不理解的,我们也会请求 BI首席架构师Pax Dickinson为我们解释那些笑话。

“编译器从不会给Jeff Dean警告的,Jeff Dean会给编译器警告的。”

解释:当你的代码有误时,编译器会给出警告,但是Jeff比编译器还牛叉。

“Jeff Dean 提交代码前会编译和运行他的代码,只是为了检验编译器和链接器有没有问题。”

解释:Jeff 的代码从不出错,他编译代码只是为了确保编译器和链接器没有bug。

“Jeff Dean 每次只给一条腿穿裤子,但是如果他有很多腿,你会发现他穿裤子的时间复杂度为O(log n)”

解释:Jeff Dean 穿裤子的算法复杂度是对数级的而不是线性级的,这样的话,如果他有很多条腿的话,就会大大节约穿裤子的时间。

“当 Richard Stallman 听说Jeff Dean的自传专属Kindle平台,他就去买了Kindle。”

解释:Richard Stallman是著名的极力反对非自由软件的人,并且从来不购买和使用Kindle。但是Jeff Dean就是这样神奇,Richard会因为想要阅读Jeff的自传而去违背自己的原则。”

“Jeff Dean 是直接写二进制机器代码的,他写源代码,是为了给其他开发人员作参考。”

解释:所有的代码在执行前都要先编译成二进制机器码,Jeff是直接写二进制机器码的,他写源代码主要是方便其他程序员理解。

“Jeff来面试谷歌时,被问到等式P=NP成立的条件,他回答,P=0 或者N=1时成立。然后在面试官哈哈大笑的时候,他看了一眼谷歌公有证书,就直接在白板上写出了相应的私钥。”

解释:“P与NP一直是计算机科学领域的一个悬而未决的问题,但是 Jeff Dean把它想成了一个代数问题,他直接用大脑根据谷歌的公有证书算出了相应的私有秘钥,这在超级计算机看来,都是不可能的事。

“X86-64 规范有几项非法指令,标志着‘私人使用’,它们其实是为Jeff Dean专用。”

解释:私有的非法CPU指令是不能被任何人使用的,但是Jeff Dean 就可以用。

“Jeff Dean 进行人体工程学评估,是为了保护他的键盘。”

解释:通常评估人体工程学是纠正坐姿,保护你的健康的,但是Jeff 却是为了保护他的键盘。

“所有的指针都是指向Jeff Dean的。”

解释:指针是C编程的核心,但是Jeff Dean 是编程世界的中心。

“在2000年末的时候,Jeff Dean 写代码的速度突然增长了40倍,原因是他把自己的键盘升级到了USB 2.0。”

解释:是键盘和计算机之间接口的速度影响了Jeff Dean 的编码速度。

原文链接: businessinsider 翻译: 伯乐在线 – JingerJoe
译文链接: http://blog.jobbole.com/51607/

Java创建对象的过程

一、检测类是否被加载
虚拟机遇到一条new指令时,首先将去检查这个指令的参数是否能在常量池中定位到一个类的符号引用,并且检查这个符号引用代表的类是否已被加载、解析和初始化过。如果没有,那必须先执行相应的类加载过程。

二、为新生对象分配内存
在类加载检查通过后,接下来虚拟机将为新生对象分配内存。对象所需内存的大小在类加载完成后便可完全确定。

假设Java堆中内存是绝对规整的,所有用过的内存都放在一边,空闲的内存放在另一边,中间放着一个指针作为分界点的指示器,那么分配内存就仅仅是把那个指针向空闲空间那边挪动一段与对象大小相等的距离,这种分配方式称为“指针碰撞”。

如果Java堆中的内存并不是规整的,已使用的内存和空闲的内存相互交错,那就没有办法简单地进行指针碰撞了,虚拟机就必须维护个列表,记录上哪些内存块是可用的,在分配的时候从列表中找到一块足够大的空间划分给对象实例,并更新列表上的记录,这种分配方式称为“空闲列表”。

选择哪种分配方式由Java堆是否规整决定,而Java堆是否规整又由所采用的垃圾收集器是否带有压缩整理功能决定。

三、初始化零值
内存分配完成后,虚拟机需要将分配到的内存空间都初始化为零值(不包括对象头),这一步操作保证了对象的实例字段在Java代码中可以不赋初始值就直接使用,程序能访问到这些字段的数据类型所对应的零值。

四、进行必要的设置
接下来,虚拟机要对对象进行必要的设置,例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对象的哈希码、对象的GC分代年龄等信息。这些信息存放在对象的对象头之中。

五、执行init方法
在上面工作都完成之后,从虚拟机的视角来看,一个新的对象已经产生了,但从Java程序的视角来看,对象创建才刚开始,方法还没有执行,所有的字段都还为零。所以一般来说,执行new指令之后会接着执行方法,把对象按照程序员的意愿进行初始化,这样一个真正可用的对象才算完全产生出来。

总结一下上面所说的,创建一个对象的过程就是:

检测类是否被加载没有加载的先加载→为新生对象分配内存→将分配到的内存空间都初始化为零值→对对象进行必要的设置→执行方法把对象进行初始化

这样一个对象就创建完成了,是不是很简单。

php redis 限流解决方案

<?php

use Predis\Client;

/**
 * Created by PhpStorm.
 * User: shichaopeng
 * Date: 2018/10/20
 * Time: 17:44
 */
class RateLimiter {

    private $client;
    private $name;
    private $maxCallsPerHour;
    private $slidingWindow;

    /**
     * RateLimiter constructor.
     * @param $client
     * @param $name
     * @param $maxCallsPerHour
     * @param $slidingWindow
     */
    public function __construct(Client $client, $name, $maxCallsPerHour, $slidingWindow) {
        $this->client = $client;
        $this->name = $name;
        $this->maxCallsPerHour = $maxCallsPerHour;
        $this->slidingWindow = $slidingWindow;
    }

    public function remaining() {
        $now = microtime(true);
        $accessToken = md5($this->name);
        $this->client->multi();
        $this->client->zrangebyscore($accessToken, 0, $now - $this->slidingWindow);
        $this->client->zrange($accessToken, 0, -1);
        $this->client->zadd($accessToken, $now, $now);
        $this->client->expire($accessToken, $this->slidingWindow);
        $result = $this->client->exec();
        $timestamps = $result[1];
        $remaining = max(0, $this->maxCallsPerHour - count($timestamps));
        return $remaining > 0;
    }


//    /**
//     * @param $key
//     * @param int $limit
//     * @param int $expire
//     * @return bool
//     */
//    function rate_limit($key, $limit = 10, $expire = 1) {
//        $redis = createRedisCli();
//        // 获取当前的计数器的值
//        $current = $redis->get($key);
//        // 如果当前计数器的值存在且计数器已经超过限制,返回失败
//        if ($current != null && $current >= $limit) {
//            return false;
//        } else {
//            // 获取计数器的存活时间
//            $ttl = $redis->ttl($key);
//            // 开始一个事务 // 命名为op2(操作2)
//            $redis->multi(Redis::MULTI);
//            // 将计数器原子加1,若计数器不存在,则创建计数器
//            $redis->incr($key);
//            // 若存活时间小于0,代表计数器之前不存在,是刚刚创建的,则设置一个存活时间
//            if ($ttl < 0) {
//                $redis->expire($key, $expire);
//            }
//            // 提交事务
//            $redis->exec();
//            return true;
//        }
//    }

}

php redis 一个信号量的实现

use Predis\Client;
use Predis\Transaction\MultiExec;
use Ramsey\Uuid\Uuid;

/**
 * Class Semaphore
 *
 * A fair, race free implementation of a counting semaphore, based on the algorithm description in
 * section 6.3 of "Redis in Action"
 * (https://redislabs.com/ebook/part-2-core-concepts/chapter-6-application-components-in-redis/6-3-counting-semaphores/)
 *
 * @package CodeOrange\RedisCountingSemaphore
 */
class Semaphore {
    private $client;
    private $name;
    private $limit;
    private $timeout;
    /** @var string $identifier Identifier for the acquired semaphore */
    private $identifier = null;

    /**
     * Semaphore constructor.
     * @param Client $client Predis client with an open connection
     * @param string $name Name of the semaphore
     * @param int $limit The amount of resources this semaphore protects
     * @param int $timeout Timeout of an acquired semaphore, in seconds
     */
    public function __construct(Client $client, $name, $limit = 1, $timeout = 10) {
        $this->client = $client;
        $this->name = $name;
        $this->limit = $limit;
        $this->timeout = $timeout;
    }

    /**
     * @return string
     */
    public function getIdentifier() {
        return $this->identifier;
    }

    /**
     * Try to acquire a semaphore
     *
     * @param float $sleep Number of seconds to sleep between retries. If null, this function will not retry but return immediately.
     * @param int $retries Number of times to retry before giving up
     * @return bool Whether or not the semaphore was acquired correctly
     */
    public function acquire($sleep = null, $retries = null) {
        if ($this->identifier) {
            // We already have it
            return true;
        }
        if ($sleep == null || $retries == null) {
            $acquired = $this->acquire_fair_with_lock();
            return $acquired;
        }

        while ($sleep > 0 && $retries > 0) {
            $acquired = $this->acquire_fair_with_lock();
            if ($acquired) {
                return true;
            }
            $retries -= 1;
            sleep($sleep);
        }
        return false;
    }

    /**
     * Release this semaphore
     *
     * @return void
     */
    public function release() {
        if (!$this->identifier) {
            // We didn't have it
            return;
        }
        if (!$this->client->isConnected()) {
            $this->client = get_predis_client();
        }
        $this->release_fair();
    }

    /**
     * Refresh the semaphore
     *
     * @return bool Whether or not we still have the semaphore
     */
    public function refresh() {
        if (!$this->identifier) {
            return false;
        }
        if (!$this->client->isConnected()) {
            $this->client = get_predis_client();
        }
        return $this->refresh_fair();
    }

    //<editor-fold desc="Methods as built up to in the book">
    private function acquire_unfair() {
        $identifier = (string)Uuid::uuid4();
        $now = time();
        $transaction = $this->client->transaction();
        // Time out old identifiers
        $transaction->zremrangebyscore($this->name, '-inf', $now - $this->timeout);
        // Try to acquire semaphore
        $transaction->zadd($this->name, [$identifier => $now]);
        // Check to see if we have it
        $transaction->zrank($this->name, $identifier);
        $result = $transaction->execute();
        $rank = $result[count($result) - 1];
        if ($rank < $this->limit) {
            // We got it!
            $this->identifier = $identifier;
            return true;
        }
        // We didn't get it, remove the identifier from the table
        $this->client->zrem($this->name, $identifier);
        return false;
    }

    private function release_unfair() {
        $id = $this->identifier;
        $this->identifier = null;
        return $this->client->zrem($this->name, $id);
    }

    private function acquire_fair() {
        $identifier = (string)Uuid::uuid4();
        $cszet = $this->name . ':owner';
        $ctr = $this->name . ':counter';
        $now = time();
        $transaction = $this->client->transaction();
        // Time out old entries
        $transaction->zremrangebyscore($this->name, '-inf', $now - $this->timeout);
        $transaction->zinterstore($cszet, [$cszet, $this->name], ['weights' => [1, 0]]);
        // Get the counter
        $transaction->incr($ctr);
        $result = $transaction->execute();
        $counter = $result[count($result) - 1];
        // Try to acquire the semaphore
        $transaction = $this->client->transaction();
        $transaction->zadd($this->name, [$identifier => $now]);
        $transaction->zadd($cszet, [$identifier => $counter]);
        // Check the rank to determine if we got the semaphore
        $transaction->zrank($cszet, $identifier);
        $result = $transaction->execute();
        $rank = $result[count($result) - 1];
        if ($rank < $this->limit) {
            // We got it!
            $this->identifier = $identifier;
            return true;
        }
        // We didn't get the semaphore, clean out the bad data
        $transaction = $this->client->transaction();
        $transaction->zrem($this->name, $identifier);
        $transaction->zrem($cszet, $identifier);
        $transaction->execute();
        return false;
    }

    private function release_fair() {
        $id = $this->identifier;
        $this->identifier = null;
        $transaction = $this->client->transaction();
        $transaction->zrem($this->name, $id);
        $transaction->zrem($this->name . ':owner', $id);
        return $transaction->execute()[0];
    }

    private function refresh_fair() {
        if ($this->client->zadd($this->name, [$this->identifier => time()])) {
            // We lost it
            $this->release_fair();
            return false;
        }
        // We still have it
        return true;
    }

    private function acquire_fair_with_lock() {
        $identifier = $this->acquire_lock(0.01);
        if ($identifier) {
            try {
                return $this->acquire_fair();
            } finally {
                $this->release_lock($identifier);
            }
        }
        return false;
    }

    // From section 6.2 of the book
    private function acquire_lock($acquire_timeout = 10) {
        $identifier = (string)Uuid::uuid4();
        $end = time() + $acquire_timeout;
        while (time() < $end) {
            $lock_name = 'lock:' . $this->name;
            $res = $this->client->setnx($lock_name, $identifier);
            if ($res) {
                //设置10s的过期时间
                $this->client->expire($lock_name, 10);
                return $identifier;
            }
            sleep(0.001);
        }
        return false;
    }

    private function release_lock($id) {
        $lock_name = 'lock:' . $this->name;
        $res = $this->client->transaction(['watch' => $lock_name, 'cas' => true, 'retry' => 1000], function (MultiExec $t) use ($id, $lock_name) {
            $value = $t->get($lock_name);
            if ($value === $id) {
                $t->multi();
                $t->del([$lock_name]);
            }
        });
        if ($res) {
            return true;
        } else {
            // We didn't execute anything, so we've lost the lock
            return false;
        }
    }
    //</editor-fold>
}

生成一个可逆的短编码

/**
     * 生成一个短的编号
     * @param $input
     * @param int $neededLength
     * @param string $alphabet
     * @return string
     */
    public function gen_short_id($input, $neededLength = 8, $alphabet = '0123456789') {
        $output = '';
        $base = strlen($alphabet);
        if (is_numeric($neededLength)) {
            $neededLength--;
            if ($neededLength > 0) {
                $input += pow($base, $neededLength);
            }
        }
        for ($current = ($input != 0 ? floor(log($input, $base)) : 0); $current >= 0; $current--) {
            $powed = pow($base, $current);
            $floored = floor($input / $powed) % $base;
            $output = $output . substr($alphabet, $floored, 1);
            $input = $input - ($floored * $powed);
        }
        return $output;
    }

    /**
     * 解析一个短的编号
     * @param $input
     * @param int $neededLength
     * @param string $alphabet
     * @return float|int
     */
    public function decode_short_id($input, $neededLength = 8, $alphabet = '0123456789') {
        $output = 0;
        $base = strlen($alphabet);
        $length = strlen($input) - 1;
        for ($current = $length; $current >= 0; $current--) {
            $powed = pow($base, $length - $current);
            $output = ($output + strpos($alphabet, substr($input, $current, 1)) * $powed);
        }
        if (is_numeric($neededLength)) {
            $neededLength--;
            if ($neededLength > 0) {
                $output -= pow($base, $neededLength);
            }
        }
        return $output;
    }

PHP 一个redis锁案例

<?php

class RedLock {
    private $retryDelay;
    private $retryCount;
    private $clockDriftFactor = 0.01;
    private $quorum;
    private $servers = array();
    private $instances = array();

    function __construct(array $servers, $retryDelay = 200, $retryCount = 0) {
        $this->servers = $servers;
        $this->retryDelay = $retryDelay;
        $this->retryCount = $retryCount;
        $this->quorum = min(count($servers), (count($servers) / 2 + 1));
    }

    public function lock($resource, $ttl) {
        $this->initInstances();
        $token = uniqid();
        $retry = $this->retryCount;
        do {
            $n = 0;
            $startTime = microtime(true) * 1000;
            foreach ($this->instances as $instance) {
                if ($this->lockInstance($instance, $resource, $token, $ttl)) {
                    $n++;
                }
            }
            # Add 2 milliseconds to the drift to account for Redis expires
            # precision, which is 1 millisecond, plus 1 millisecond min drift
            # for small TTLs.
            $drift = ($ttl * $this->clockDriftFactor) + 2;
            $validityTime = $ttl - (microtime(true) * 1000 - $startTime) - $drift;
            if ($n >= $this->quorum && $validityTime > 0) {
                return [
                    'validity' => $validityTime,
                    'resource' => $resource,
                    'token' => $token,
                ];
            } else {
                foreach ($this->instances as $instance) {
                    $this->unlockInstance($instance, $resource, $token);
                }
            }
            // Wait a random delay before to retry
            $delay = mt_rand(floor($this->retryDelay / 2), $this->retryDelay);
            usleep($delay * 1000);
            $retry--;
        } while ($retry > 0);
        return false;
    }

    public function unlock(array $lock) {
        $this->initInstances();
        $resource = $lock['resource'];
        $token = $lock['token'];
        foreach ($this->instances as $instance) {
            $this->unlockInstance($instance, $resource, $token);
        }
    }

    private function initInstances() {
        if (empty($this->instances)) {
            foreach ($this->servers as $server) {
                list($host, $port, $timeout) = $server;
                $redis = new \Redis();
                $redis->connect($host, $port, $timeout);
                $this->instances[] = $redis;
            }
        }
    }

    private function lockInstance($instance, $resource, $token, $ttl) {
        return $instance->set($resource, $token, ['NX', 'PX' => $ttl]);
    }

    private function unlockInstance($instance, $resource, $token) {
        $script = '
            if redis.call("GET", KEYS[1]) == ARGV[1] then
                return redis.call("DEL", KEYS[1])
            else
                return 0
            end
        ';
        return $instance->eval($script, [$resource, $token], 1);
    }
}

简易版实现

use Ramsey\Uuid\Uuid;

class RedisLock {

    private $redis;

    /**
     * RedisLock constructor.
     * @param $redis Redis
     */
    public function __construct($redis) {
        $this->redis = $redis;
    }

    /**
     * @param $lock_name
     * @param int $acquire_time
     * @param int $lock_timeout
     * @return bool|string
     *
     * @throws Exception
     */
    public function acquire_lock($lock_name, $acquire_time = 0, $lock_timeout = 10) {
        $identifier = (string)Uuid::uuid4();
        $lock_name = 'lock:' . $lock_name;
        $lock_timeout = intval(ceil($lock_timeout));
        if ($acquire_time == 0) {
            $result = $this->got_lock($lock_name, $identifier, $lock_timeout);
        } else {
            $end_time = time() + $acquire_time;
            while (time() < $end_time) {
                $result = $this->got_lock($lock_name, $identifier, $lock_timeout);
                if ($result != '1') {
                    //sleep 0.1 sec
                    usleep(100000);
                }
            }
        }
        return $result == '1' ? $identifier : false;
    }

    private function got_lock($lock_name, $identifier, $lock_timeout) {
        $script = <<<luascript
                 local result = redis.call('setnx',KEYS[1],ARGV[1]);
                    if result == 1 then
                        redis.call('expire',KEYS[1],ARGV[2])
                        return 1
                    elseif redis.call('ttl',KEYS[1]) == -1 then
                       redis.call('expire',KEYS[1],ARGV[2])
                       return 0
                    end
                    return 0
luascript;
        $result = $this->redis->evaluate($script, array($lock_name, $identifier, $lock_timeout), 1);
        return $result;
    }

    /**
     * @param $lock_name
     * @param $identifier
     * @return bool
     */
    public function release_lock($lock_name, $identifier) {
        $lock_name = 'lock:' . $lock_name;
        while (true) {
            $script = <<<luascript
                local result = redis.call('get',KEYS[1]);
                if result == ARGV[1] then
                    if redis.call('del',KEYS[1]) == 1 then
                        return 1;
                    end
                end
                return 0
luascript;
            $result = $this->redis->evaluate($script, array($lock_name, $identifier), 1);
            if ($result == 1) {
                return true;
            }
            break;
        }
        return false;
    }
}

Java io & nio

IO流学习总结

一 Java IO,硬骨头也能变软

(1) 按操作方式分类结构图:

IO-操作方式分类

(2)按操作对象分类结构图

IO-操作对象分类

二 java IO体系的学习总结

  1. IO流的分类:
    • 按照流的流向分,可以分为输入流和输出流;
    • 按照操作单元划分,可以划分为字节流和字符流;
    • 按照流的角色划分为节点流和处理流。
  2. 流的原理浅析:

    java Io流共涉及40多个类,这些类看上去很杂乱,但实际上很有规则,而且彼此之间存在非常紧密的联系, Java Io流的40多个类都是从如下4个抽象类基类中派生出来的。

  • InputStream/Reader: 所有的输入流的基类,前者是字节输入流,后者是字符输入流。
  • OutputStream/Writer: 所有输出流的基类,前者是字节输出流,后者是字符输出流。
    1. 常用的io流的用法

三 Java IO面试题

NIO与AIO学习总结

一 Java NIO 概览

  1. NIO简介:

    Java NIO 是 java 1.4, 之后新出的一套IO接口NIO中的N可以理解为Non-blocking,不单纯是New。

  2. NIO的特性/NIO与IO区别:

    • 1)IO是面向流的,NIO是面向缓冲区的;
    • 2)IO流是阻塞的,NIO流是不阻塞的;
    • 3)NIO有选择器,而IO没有。
  3. 读数据和写数据方式:
    • 从通道进行数据读取 :创建一个缓冲区,然后请求通道读取数据。

    • 从通道进行数据写入 :创建一个缓冲区,填充数据,并要求通道写入数据。

  4. NIO核心组件简单介绍

    • Channels
    • Buffers
    • Selectors

二 Java NIO 之 Buffer(缓冲区)

  1. Buffer(缓冲区)介绍:
    • Java NIO Buffers用于和NIO Channel交互。 我们从Channel中读取数据到buffers里,从Buffer把数据写入到Channels;
    • Buffer本质上就是一块内存区;
    • 一个Buffer有三个属性是必须掌握的,分别是:capacity容量、position位置、limit限制。
  2. Buffer的常见方法
    • Buffer clear()
    • Buffer flip()
    • Buffer rewind()
    • Buffer position(int newPosition)
  3. Buffer的使用方式/方法介绍:
    • 分配缓冲区(Allocating a Buffer):
    ByteBuffer buf = ByteBuffer.allocate(28);//以ByteBuffer为例子
    
    • 写入数据到缓冲区(Writing Data to a Buffer)

      写数据到Buffer有两种方法:

      1.从Channel中写数据到Buffer

      int bytesRead = inChannel.read(buf); //read into buffer.
      

      2.通过put写数据:

      buf.put(127);
      
  4. Buffer常用方法测试

    说实话,NIO编程真的难,通过后面这个测试例子,你可能才能勉强理解前面说的Buffer方法的作用。

三 Java NIO 之 Channel(通道)

  1. Channel(通道)介绍
    • 通常来说NIO中的所有IO都是从 Channel(通道) 开始的。
    • NIO Channel通道和流的区别:
  2. FileChannel的使用
  3. SocketChannel和ServerSocketChannel的使用
  4. ️DatagramChannel的使用
  5. Scatter / Gather
    • Scatter: 从一个Channel读取的信息分散到N个缓冲区中(Buufer).
    • Gather: 将N个Buffer里面内容按照顺序发送到一个Channel.
  6. 通道之间的数据传输
    • 在Java NIO中如果一个channel是FileChannel类型的,那么他可以直接把数据传输到另一个channel。
    • transferFrom() :transferFrom方法把数据从通道源传输到FileChannel
    • transferTo() :transferTo方法把FileChannel数据传输到另一个channel

四 Java NIO之Selector(选择器)

  1. Selector(选择器)介绍
    • Selector 一般称 为选择器 ,当然你也可以翻译为 多路复用器 。它是Java NIO核心组件中的一个,用于检查一个或多个NIO Channel(通道)的状态是否处于可读、可写。如此可以实现单线程管理多个channels,也就是可以管理多个网络链接。
    • 使用Selector的好处在于: 使用更少的线程来就可以来处理通道了, 相比使用多个线程,避免了线程上下文切换带来的开销。
  2. Selector(选择器)的使用方法介绍

    • Selector的创建
    Selector selector = Selector.open();
    
    • 注册Channel到Selector(Channel必须是非阻塞的)
    channel.configureBlocking(false);
    SelectionKey key = channel.register(selector, Selectionkey.OP_READ);
    
    • SelectionKey介绍

      一个SelectionKey键表示了一个特定的通道对象和一个特定的选择器对象之间的注册关系。

    • 从Selector中选择channel(Selecting Channels via a Selector)

      选择器维护注册过的通道的集合,并且这种注册关系都被封装在SelectionKey当中.

    • 停止选择的方法

      wakeup()方法 和close()方法。

  3. 模板代码

    有了模板代码我们在编写程序时,大多数时间都是在模板代码中添加相应的业务代码。

  4. 客户端与服务端简单交互实例

五 Java NIO之拥抱Path和Files

一 文件I/O基石:Path:
– 创建一个Path
– File和Path之间的转换,File和URI之间的转换
– 获取Path的相关信息
– 移除Path中的冗余项

二 拥抱Files类:
– Files.exists() 检测文件路径是否存在
– Files.createFile() 创建文件
– Files.createDirectories()和Files.createDirectory()创建文件夹
– Files.delete()方法 可以删除一个文件或目录
– Files.copy()方法可以吧一个文件从一个地址复制到另一个位置
– 获取文件属性
– 遍历一个文件夹
– Files.walkFileTree()遍历整个目录

六 NIO学习总结以及NIO新特性介绍

  • 内存映射:

这个功能主要是为了提高大文件的读写速度而设计的。内存映射文件(memory-mappedfile)能让你创建和修改那些大到无法读入内存的文件。有了内存映射文件,你就可以认为文件已经全部读进了内存,然后把它当成一个非常大的数组来访问了。将文件的一段区域映射到内存中,比传统的文件处理速度要快很多。内存映射文件它虽然最终也是要从磁盘读取数据,但是它并不需要将数据读取到OS内核缓冲区,而是直接将进程的用户私有地址空间中的一部分区域与文件对象建立起映射关系,就好像直接从内存中读、写文件一样,速度当然快了。

七 Java NIO AsynchronousFileChannel异步文件通

Java7中新增了AsynchronousFileChannel作为nio的一部分。AsynchronousFileChannel使得数据可以进行异步读写。

八 高并发Java(8):NIO和AIO

推荐阅读

在 Java 7 中体会 NIO.2 异步执行的快乐

Java AIO总结与示例

AIO是异步IO的缩写,虽然NIO在网络操作中,提供了非阻塞的方法,但是NIO的IO行为还是同步的。对于NIO来说,我们的业务线程是在IO操作准备好时,得到通知,接着就由这个线程自行进行IO操作,IO操作本身是同步的。

欢迎关注我的微信公众号:”Java面试通关手册”(一个有温度的微信公众号,期待与你共同进步~~~坚持原创,分享美文,分享各种Java学习资源):

JAVA 多线程总结

1、并发编程三要素?

1)原子性

原子性指的是一个或者多个操作,要么全部执行并且在执行的过程中不被其他操作打断,要么就全部都不执行。

2)可见性

可见性指多个线程操作一个共享变量时,其中一个线程对变量进行修改后,其他线程可以立即看到修改的结果。

3)有序性

有序性,即程序的执行顺序按照代码的先后顺序来执行。

2、实现可见性的方法有哪些?

synchronized或者Lock:保证同一个时刻只有一个线程获取锁执行代码,锁释放之前把最新的值刷新到主内存,实现可见性。

3、多线程的价值?

1)发挥多核CPU的优势

多线程,可以真正发挥出多核CPU的优势来,达到充分利用CPU的目的,采用多线程的方式去同时完成几件事情而不互相干扰。

2)防止阻塞

从程序运行效率的角度来看,单核CPU不但不会发挥出多线程的优势,反而会因为在单核CPU上运行多线程导致线程上下文的切换,而降低程序整体的效率。但是单核CPU我们还是要应用多线程,就是为了防止阻塞。试想,如果单核CPU使用单线程,那么只要这个线程阻塞了,比方说远程读取某个数据吧,对端迟迟未返回又没有设置超时时间,那么你的整个程序在数据返回回来之前就停止运行了。多线程可以防止这个问题,多条线程同时运行,哪怕一条线程的代码执行读取数据阻塞,也不会影响其它任务的执行。

3)便于建模

这是另外一个没有这么明显的优点了。假设有一个大的任务A,单线程编程,那么就要考虑很多,建立整个程序模型比较麻烦。但是如果把这个大的任务A分解成几个小任务,任务B、任务C、任务D,分别建立程序模型,并通过多线程分别运行这几个任务,那就简单很多了。

3、创建线程的有哪些方式?

1)继承Thread类创建线程类

2)通过Runnable接口创建线程类

3)通过Callable和Future创建线程

4)通过线程池创建

4.创建线程的三种方式的对比?

1)采用实现Runnable、Callable接口的方式创建多线程。

优势是

线程类只是实现了Runnable接口或Callable接口,还可以继承其他类。

在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。

劣势是:

编程稍微复杂,如果要访问当前线程,则必须使用Thread.currentThread()方法。

2)使用继承Thread类的方式创建多线程

优势是:

编写简单,如果需要访问当前线程,则无需使用Thread.currentThread()方法,直接使用this即可获得当前线程。

劣势是:

线程类已经继承了Thread类,所以不能再继承其他父类。

3)Runnable和Callable的区别

  • Callable规定(重写)的方法是call(),Runnable规定(重写)的方法是run()。
  • Callable的任务执行后可返回值,而Runnable的任务是不能返回值的。
  • Call方法可以抛出异常,run方法不可以。
  • 运行Callable任务可以拿到一个Future对象,表示异步计算的结果。它提供了检查计算是否完成的方法,以等待计算的完成,并检索计算的结果。通过Future对象可以了解任务执行情况,可取消任务的执行,还可获取执行结果。

5、线程的状态流转图

线程的生命周期及五种基本状态:

6.Java线程具有五中基本状态

1)新建状态(New):当线程对象对创建后,即进入了新建状态,如:Thread t = new MyThread();

2)就绪状态(Runnable):当调用线程对象的start()方法(t.start();),线程即进入就绪状态。处于就绪状态的线程,只是说明此线程已经做好了准备,随时等待CPU调度执行,并不是说执行了t.start()此线程立即就会执行;

3)运行状态(Running):当CPU开始调度处于就绪状态的线程时,此时线程才得以真正执行,即进入到运行状态。注:就 绪状态是进入到运行状态的唯一入口,也就是说,线程要想进入运行状态执行,首先必须处于就绪状态中;

4)阻塞状态(Blocked):处于运行状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入到就绪状态,才 有机会再次被CPU调用以进入到运行状态。

根据阻塞产生的原因不同,阻塞状态又可以分为三种:

1.等待阻塞:运行状态中的线程执行wait()方法,使本线程进入到等待阻塞状态;

2.同步阻塞 — 线程在获取synchronized同步锁失败(因为锁被其它线程所占用),它会进入同步阻塞状态;

3.其他阻塞 — 通过调用线程的sleep()或join()或发出了I/O请求时,线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。

5)死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。

7.什么是线程池?有哪几种创建方式?

线程池就是提前创建若干个线程,如果有任务需要处理,线程池里的线程就会处理任务,处理完之后线程并不会被销毁,而是等待下一个任务。由于创建和销毁线程都是消耗系统资源的,所以当你想要频繁的创建和销毁线程的时候就可以考虑使用线程池来提升系统的性能。

java 提供了一个 java.util.concurrent.Executor接口的实现用于创建线程池。

8.四种线程池的创建

(1)newCachedThreadPool创建一个可缓存线程池

(2)newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数。

(3)newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行。

(4)newSingleThreadExecutor 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务。

9.线程池的优点?

1)重用存在的线程,减少对象创建销毁的开销。

2)可有效的控制最大并发线程数,提高系统资源的使用率,同时避免过多资源竞争,避免堵塞。

3)提供定时执行、定期执行、单线程、并发数控制等功能。

10.常用的并发工具类有哪些?

  • CountDownLatch
  • CyclicBarrier
  • Semaphore
  • Exchanger

11.CyclicBarrier和CountDownLatch的区别

1)CountDownLatch简单的说就是一个线程等待,直到他所等待的其他线程都执行完成并且调用countDown()方法发出通知后,当前线程才可以继续执行。

2)cyclicBarrier是所有线程都进行等待,直到所有线程都准备好进入await()方法之后,所有线程同时开始执行!

3)CountDownLatch的计数器只能使用一次。而CyclicBarrier的计数器可以使用reset() 方法重置。所以CyclicBarrier能处理更为复杂的业务场景,比如如果计算发生错误,可以重置计数器,并让线程们重新执行一次。

4)CyclicBarrier还提供其他有用的方法,比如getNumberWaiting方法可以获得CyclicBarrier阻塞的线程数量。isBroken方法用来知道阻塞的线程是否被中断。如果被中断返回true,否则返回false。

12.synchronized的作用?

在Java中,synchronized关键字是用来控制线程同步的,就是在多线程的环境下,控制synchronized代码段不被多个线程同时执行。

synchronized既可以加在一段代码上,也可以加在方法上。

13.volatile关键字的作用

对于可见性,Java提供了volatile关键字来保证可见性。

当一个共享变量被volatile修饰时,它会保证修改的值会立即被更新到主存,当有其他线程需要读取时,它会去内存中读取新值。

从实践角度而言,volatile的一个重要作用就是和CAS结合,保证了原子性,详细的可以参见java.util.concurrent.atomic包下的类,比如AtomicInteger。

14.什么是CAS

CAS是compare and swap的缩写,即我们所说的比较交换。

cas是一种基于锁的操作,而且是乐观锁。在java中锁分为乐观锁和悲观锁。悲观锁是将资源锁住,等一个之前获得锁的线程释放锁之后,下一个线程才可以访问。而乐观锁采取了一种宽泛的态度,通过某种方式不加锁来处理资源,比如通过给记录加version来获取数据,性能较悲观锁有很大的提高。

CAS 操作包含三个操作数 —— 内存位置(V)、预期原值(A)和新值(B)。如果内存地址里面的值和A的值是一样的,那么就将内存里面的值更新成B。CAS是通过无限循环来获取数据的,若果在第一轮循环中,a线程获取地址里面的值被b线程修改了,那么a线程需要自旋,到下次循环才有可能机会执行。

java.util.concurrent.atomic 包下的类大多是使用CAS操作来实现的( AtomicInteger,AtomicBoolean,AtomicLong)。

15. CAS的问题

1)CAS容易造成ABA问题。一个线程a将数值改成了b,接着又改成了a,此时CAS认为是没有变化,其实是已经变化过了,而这个问题的解决方案可以使用版本号标识,每操作一次version加1。在java5中,已经提供了AtomicStampedReference来解决问题。

2) 不能保证代码块的原子性

CAS机制所保证的知识一个变量的原子性操作,而不能保证整个代码块的原子性。比如需要保证3个变量共同进行原子性的更新,就不得不使用synchronized了。

3)CAS造成CPU利用率增加。之前说过了CAS里面是一个循环判断的过程,如果线程一直没有获取到状态,cpu资源会一直被占用。

16.什么是Future?

在并发编程中,我们经常用到非阻塞的模型,在之前的多线程的三种实现中,不管是继承thread类还是实现runnable接口,都无法保证获取到之前的执行结果。通过实现Callback接口,并用Future可以来接收多线程的执行结果。

Future表示一个可能还没有完成的异步任务的结果,针对这个结果可以添加Callback以便在任务执行成功或失败后作出相应的操作。

17.什么是AQS

AQS是AbustactQueuedSynchronizer的简称,它是一个Java提高的底层同步工具类,用一个int类型的变量表示同步状态,并提供了一系列的CAS操作来管理这个同步状态。

AQS是一个用来构建锁和同步器的框架,使用AQS能简单且高效地构造出应用广泛的大量的同步器,比如我们提到的ReentrantLock,Semaphore,其他的诸如ReentrantReadWriteLock,SynchronousQueue,FutureTask等等皆是基于AQS的。

18. AQS支持两种同步方式:

 1.独占式

2.共享式

这样方便使用者实现不同类型的同步组件,独占式如ReentrantLock,共享式如Semaphore,CountDownLatch,组合式的如ReentrantReadWriteLock。总之,AQS为使用提供了底层支撑,如何组装实现,使用者可以自由发挥。

19.ReadWriteLock是什么

首先明确一下,不是说ReentrantLock不好,只是ReentrantLock某些时候有局限。如果使用ReentrantLock,可能本身是为了防止线程A在写数据、线程B在读数据造成的数据不一致,但这样,如果线程C在读数据、线程D也在读数据,读数据是不会改变数据的,没有必要加锁,但是还是加锁了,降低了程序的性能。

因为这个,才诞生了读写锁ReadWriteLock。ReadWriteLock是一个读写锁接口,ReentrantReadWriteLock是ReadWriteLock接口的一个具体实现,实现了读写的分离,读锁是共享的,写锁是独占的,读和读之间不会互斥,读和写、写和读、写和写之间才会互斥,提升了读写的性能。

20.FutureTask是什么

这个其实前面有提到过,FutureTask表示一个异步运算的任务。FutureTask里面可以传入一个Callable的具体实现类,可以对这个异步运算的任务的结果进行等待获取、判断是否已经完成、取消任务等操作。当然,由于FutureTask也是Runnable接口的实现类,所以FutureTask也可以放入线程池中。

21.synchronized和ReentrantLock的区别

synchronized是和if、else、for、while一样的关键字,ReentrantLock是类,这是二者的本质区别。既然ReentrantLock是类,那么它就提供了比synchronized更多更灵活的特性,可以被继承、可以有方法、可以有各种各样的类变量,ReentrantLock比synchronized的扩展性体现在几点上:

(1)ReentrantLock可以对获取锁的等待时间进行设置,这样就避免了死锁

(2)ReentrantLock可以获取各种锁的信息

(3)ReentrantLock可以灵活地实现多路通知

另外,二者的锁机制其实也是不一样的。ReentrantLock底层调用的是Unsafe的park方法加锁,synchronized操作的应该是对象头中mark word,这点我不能确定。

22.什么是乐观锁和悲观锁

(1)乐观锁:就像它的名字一样,对于并发间操作产生的线程安全问题持乐观状态,乐观锁认为竞争不总是会发生,因此它不需要持有锁,将比较-替换这两个动作作为一个原子操作尝试去修改内存中的变量,如果失败则表示发生冲突,那么就应该有相应的重试逻辑。

(2)悲观锁:还是像它的名字一样,对于并发间操作产生的线程安全问题持悲观状态,悲观锁认为竞争总是会发生,因此每次对某资源进行操作时,都会持有一个独占的锁,就像synchronized,不管三七二十一,直接上了锁就操作资源了。

23.线程B怎么知道线程A修改了变量

  • volatile修饰变量
  • synchronized修饰修改变量的方法
  • wait/notify
  • while轮询

24.synchronized、volatile、CAS比较

  • synchronized是悲观锁,属于抢占式,会引起其他线程阻塞。
  • volatile提供多线程共享变量可见性和禁止指令重排序优化。
  • CAS是基于冲突检测的乐观锁(非阻塞)

25.sleep方法和wait方法有什么区别?

这个问题常问,sleep方法和wait方法都可以用来放弃CPU一定的时间,不同点在于如果线程持有某个对象的监视器,sleep方法不会放弃这个对象的监视器,wait方法会放弃这个对象的监视器

26.ThreadLocal是什么?有什么用?

ThreadLocal是一个本地线程副本变量工具类。主要用于将私有线程和该线程存放的副本对象做一个映射,各个线程之间的变量互不干扰,在高并发场景下,可以实现无状态的调用,特别适用于各个线程依赖不通的变量值完成操作的场景。

简单说ThreadLocal就是一种以空间换时间的做法,在每个Thread里面维护了一个以开地址法实现的ThreadLocal.ThreadLocalMap,把数据进行隔离,数据不共享,自然就没有线程安全方面的问题了。

27.为什么wait()方法和notify()/notifyAll()方法要在同步块中被调用

这是JDK强制的,wait()方法和notify()/notifyAll()方法在调用前都必须先获得对象的锁

28.多线程同步有哪几种方法?

Synchronized关键字,Lock锁实现,分布式锁等。

29.线程的调度策略

线程调度器选择优先级最高的线程运行,但是,如果发生以下情况,就会终止线程的运行:

(1)线程体中调用了yield方法让出了对cpu的占用权利

(2)线程体中调用了sleep方法使线程进入睡眠状态

(3)线程由于IO操作受到阻塞

(4)另外一个更高优先级线程出现

(5)在支持时间片的系统中,该线程的时间片用完

30.ConcurrentHashMap的并发度是什么

ConcurrentHashMap的并发度就是segment的大小,默认为16,这意味着最多同时可以有16条线程操作ConcurrentHashMap,这也是ConcurrentHashMap对Hashtable的最大优势,任何情况下,Hashtable能同时有两条线程获取Hashtable中的数据吗?

31.Linux环境下如何查找哪个线程使用CPU最长

(1)获取项目的pid,jps或者ps -ef | grep java,这个前面有讲过

(2)top -H -p pid,顺序不能改变

32.Java死锁以及如何避免?

Java中的死锁是一种编程情况,其中两个或多个线程被永久阻塞,Java死锁情况出现至少两个线程和两个或更多资源。

Java发生死锁的根本原因是:在申请锁时发生了交叉闭环申请。

33.死锁的原因

1)是多个线程涉及到多个锁,这些锁存在着交叉,所以可能会导致了一个锁依赖的闭环。

例如:线程在获得了锁A并且没有释放的情况下去申请锁B,这时,另一个线程已经获得了锁B,在释放锁B之前又要先获得锁A,因此闭环发生,陷入死锁循环。

2)默认的锁申请操作是阻塞的

所以要避免死锁,就要在一遇到多个对象锁交叉的情况,就要仔细审查这几个对象的类中的所有方法,是否存在着导致锁依赖的环路的可能性。总之是尽量避免在一个同步方法中调用其它对象的延时方法和同步方法。

34.怎么唤醒一个阻塞的线程

如果线程是因为调用了wait()、sleep()或者join()方法而导致的阻塞,可以中断线程,并且通过抛出InterruptedException来唤醒它;如果线程遇到了IO阻塞,无能为力,因为IO是操作系统实现的,Java代码并没有办法直接接触到操作系统。

35.不可变对象对多线程有什么帮助

前面有提到过的一个问题,不可变对象保证了对象的内存可见性,对不可变对象的读取不需要进行额外的同步手段,提升了代码执行效率。

36.什么是多线程的上下文切换

多线程的上下文切换是指CPU控制权由一个已经正在运行的线程切换到另外一个就绪并等待获取CPU执行权的线程的过程。

37.如果你提交任务时,线程池队列已满,这时会发生什么

这里区分一下:

  1. 如果使用的是无界队列LinkedBlockingQueue,也就是无界队列的话,没关系,继续添加任务到阻塞队列中等待执行,因为LinkedBlockingQueue可以近乎认为是一个无穷大的队列,可以无限存放任务
  2. 如果使用的是有界队列比如ArrayBlockingQueue,任务首先会被添加到ArrayBlockingQueue中,ArrayBlockingQueue满了,会根据maximumPoolSize的值增加线程数量,如果增加了线程数量还是处理不过来,ArrayBlockingQueue继续满,那么则会使用拒绝策略RejectedExecutionHandler处理满了的任务,默认是AbortPolicy

38.Java中用到的线程调度算法是什么

抢占式。一个线程用完CPU之后,操作系统会根据线程优先级、线程饥饿情况等数据算出一个总的优先级并分配下一个时间片给某个线程执行。

39.什么是线程调度器(Thread Scheduler)和时间分片(Time Slicing)?

线程调度器是一个操作系统服务,它负责为Runnable状态的线程分配CPU时间。一旦我们创建一个线程并启动它,它的执行便依赖于线程调度器的实现。时间分片是指将可用的CPU时间分配给可用的Runnable线程的过程。分配CPU时间可以基于线程优先级或者线程等待的时间。线程调度并不受到Java虚拟机控制,所以由应用程序来控制它是更好的选择(也就是说不要让你的程序依赖于线程的优先级)。

40.什么是自旋

很多synchronized里面的代码只是一些很简单的代码,执行时间非常快,此时等待的线程都加锁可能是一种不太值得的操作,因为线程阻塞涉及到用户态和内核态切换的问题。既然synchronized里面的代码执行得非常快,不妨让等待锁的线程不要被阻塞,而是在synchronized的边界做忙循环,这就是自旋。如果做了多次忙循环发现还没有获得锁,再阻塞,这样可能是一种更好的策略。

41.Java Concurrency API中的Lock接口(Lock interface)是什么?对比同步它有什么优势?

Lock接口比同步方法和同步块提供了更具扩展性的锁操作。他们允许更灵活的结构,可以具有完全不同的性质,并且可以支持多个相关类的条件对象。

它的优势有:

  • 可以使锁更公平
  • 可以使线程在等待锁的时候响应中断
  • 可以让线程尝试获取锁,并在无法获取锁的时候立即返回或者等待一段时间
  • 可以在不同的范围,以不同的顺序获取和释放锁

42.单例模式的线程安全性

老生常谈的问题了,首先要说的是单例模式的线程安全意味着:某个类的实例在多线程环境下只会被创建一次出来。单例模式有很多种的写法,我总结一下:

(1)饿汉式单例模式的写法:线程安全

(2)懒汉式单例模式的写法:非线程安全

(3)双检锁单例模式的写法:线程安全

43.Semaphore有什么作用

Semaphore就是一个信号量,它的作用是限制某段代码块的并发数。Semaphore有一个构造函数,可以传入一个int型整数n,表示某段代码最多只有n个线程可以访问,如果超出了n,那么请等待,等到某个线程执行完毕这段代码块,下一个线程再进入。由此可以看出如果Semaphore构造函数中传入的int型整数n=1,相当于变成了一个synchronized了。

44.Executors类是什么?

Executors为Executor,ExecutorService,ScheduledExecutorService,ThreadFactory和Callable类提供了一些工具方法。

Executors可以用于方便的创建线程池

45.线程类的构造方法、静态块是被哪个线程调用的

这是一个非常刁钻和狡猾的问题。请记住:线程类的构造方法、静态块是被new这个线程类所在的线程所调用的,而run方法里面的代码才是被线程自身所调用的。

如果说上面的说法让你感到困惑,那么我举个例子,假设Thread2中new了Thread1,main函数中new了Thread2,那么:

(1)Thread2的构造方法、静态块是main线程调用的,Thread2的run()方法是Thread2自己调用的

(2)Thread1的构造方法、静态块是Thread2调用的,Thread1的run()方法是Thread1自己调用的

46.同步方法和同步块,哪个是更好的选择?

同步块,这意味着同步块之外的代码是异步执行的,这比同步整个方法更提升代码的效率。请知道一条原则:同步的范围越小越好

47.Java线程数过多会造成什么异常?

1)线程的生命周期开销非常高

2)消耗过多的CPU资源

如果可运行的线程数量多于可用处理器的数量,那么有线程将会被闲置。大量空闲的线程会占用许多内存,给垃圾回收器带来压力,而且大量的线程在竞争CPU资源时还将产生其他性能的开销。

3)降低稳定性

JVM在可创建线程的数量上存在一个限制,这个限制值将随着平台的不同而不同,并且承受着多个因素制约,包括JVM的启动参数、Thread构造函数中请求栈的大小,以及底层操作系统对线程的限制等。如果破坏了这些限制,那么可能抛出OutOfMemoryError异常。

MYSQL EXPLAIN解析一 EXTRA中的USING INDEX,USING WHERE,USING INDEX CONDITION

1.简单介绍

using index 和using where只要使用了索引我们基本都能经常看到,而using index condition则是在mysql5.6后新加的新特性,我们先来看看mysql文档对using index condition的描述

附上mysql文档链接:https://dev.mysql.com/doc/refman/5.7/en/index-condition-pushdown-optimization.html

简单来说,mysql开启了ICP的话,可以减少存储引擎访问基表的次数

下面来简单的介绍一下这三者的区别

using index :使用覆盖索引的时候就会出现

using where:在查找使用索引的情况下,需要回表去查询所需的数据

using index condition:查找使用了索引,但是需要回表查询数据

using index & using where:查找使用了索引,但是需要的数据都在索引列中能找到,所以不需要回表查询数据

以上四点就能看出它们之前的区别,或许有部分人都存在疑惑 using index & using where 和using index condition那个比较好,从上面的的解释中就能看出是前者比较好,毕竟不需要回表查询数据,效率上应该比较快的

下面是在stackoverflow中找到的答案:

附上stackoverflow链接:https://stackoverflow.com/questions/28759576/mysql-using-index-condition-vs-using-where-using-index

 

2.测试验证

(1)建立一个userinfo表,其字段信息如下图所示:

 

(2)查询测试

(2.1)测试Using index

覆盖索引,但是没有使用查询条件,所以只有Using index

(2.2)测试Using index & Using where

覆盖索引,但是后面带了查询条件,所以也用了Using where查询索引

(2.3)测试Using index condition

因为本人用的是mysql版本是5.5,所以显示了Using where,如果用5.6以上的版本应该就会显示Using index condition,个人认为,Using index condition其实就是优化了Using where这种情况,有条件的也可以自己写个demo测试一下

以上皆为个人理解,如果有理解错的地方,欢迎指出