ireneliu 发布的文章

1、数据库语句中<>是不等于的意思,!=不完全正确, 所以最好用<>

2、substr(string,pos,len) 截取从第pos位置开始,长度为len的字符串

substr(string, 1, 3) //str
substr(string, -1, 3) //g -1代表从右边第一个位置开始计算
substr(string, -3, 2) //in

substr(string, pos) 截取从第pos位置开始,到最后的字符串

sub(string, 2) //tring

3、DB2更新语句

UPDATE 表名 SET BIRTHDAY='1991-1-5' WHERE NAME='张三';
UPDATE
(
    SELECT * FROM 表名 WHERE NAME='张三'
)
SET BIRTHDAY='1991-1-5'

1、什么是可重入锁(ReentrantLock)?

举例来说明锁的可重入性
public class UnReentrant {
    Lock lock = new Lock();
    public void outer() {
        lock.lock();
        inner();
        lock.inlock();
    }
    public void inner() {
        lock.lock();
        //do something;
        lock.unlick();
    }
}
outer 中调用了 inner,outer 先锁住了 lock,这样 inner 就不能再获取 lock。其实调用 outer 的线程已经获取了 lock 锁,但是不能在 inner 中重复利用已经获取的锁资源,这种锁即称之为不可重入。可重入就意味着:线程可以进入任何一个他已经拥有的锁所同步着的代码块。

synchronized、ReentrantLock 都是可重入的锁,可重入锁相对来说简化了并发编程的开发。

2、当一个线程进入某个对象的一个 synchronized 的实例方法后,其他线程是否可进入此对象的其他方法?

如果其他方法没有 synchronized 的话,其他线程是可以进入的,
所以要开放一个线程安全的对象时,得保证每个方法都是线程安全的。

3、乐观锁和悲观锁的理解及如何实现,有哪些实现方法?

悲观锁:总是假设最坏的情况,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会阻塞直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制,比如,行锁,表锁,读锁,写锁等,都是在操作之前先上锁。再比如 Java 里面的同步原语 synchronized 关键字色实现也是悲观锁。

乐观锁:顾名思义,就是很乐观,每次去拿数据的数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号等机制。乐观锁适用于多读的应用类型,这样可以提高吞吐量,像数据库提供的类似于 write_condition 机制,其实都是提供的乐观锁。在 Java 中,java.util.concurrent.atomic 包下面的原子变量类就是使用了乐观锁的一种实现方式 CAS 实现的。

乐观锁的实现方式:
使用版本标识来确定读到的数据与提交时的数据是否一致。提交后修改版本标识,不一致时可以采取丢弃和再次尝试的策略。
java 中的 Compare and Swap 即 CAS,当多个线程尝试使用 CAS 同时更新一个变量时,只有其中一个线程能更新变量的值,而其他线程都失败,失败的线程并不会被挂起,而是被告知这次竞争中失败,并可以再次尝试。CAS 操作中包含三个操作数——需要读写的内存位置(V)、进行比较的预期原值(A)和拟写入的新值(B),如果内存位置V的值与预期原值A相匹配,那么处理器会自动将该位置值更新为新值B。否则处理器不做任何操作。

CAS 缺点:
ABA 问题:
比如说一个线程one 从 内存位置V 中取出 A,这时候另外一个线程two 也从内存中取出 A,并且 two 进行了一些操作变成了 B,然后 two 有将 V位置的数据变成 A,这时候线程one 进行 CAS 操作发现内存中仍然是 A,然后 one 操作成功。尽管线程 one 的 CAS 操作成功,但可能存在潜藏的问题。从 Java1.5 开始 JDK 的 atomic 包里提供了一个类 AtomicStampedReference 来解决 ABA 问题。
循环时间长开销大:
对于资源竞争严重(线程严重冲突)的情况,CAS 自旋的概率会比较大,从而浪费更多的 CPU 资源,效率低于 synchronized。
只能保证一个共享变量的原子操作:
当对一个共享变量执行操作时,我们可以使用 循环CAS 的方式来保证原子操作,但是对多个共享变量操作时,循环 CAS 就无法保证操作的原子性,这个时候就可以用锁。

4、SynchronizedMap 和 ConcurrentHashMap 有什么区别?

SynchronizedMap 一次锁住整张表来保证线程安全,所以每次只能有一个线程来访问 map。
ConcurrentHashMap 使用分段锁来保证在多线程下的性能。ConcurrentHashMap 中则是一次锁住一个桶。ConcurrentHashMap 默认将 hash表 分为16个桶,诸如,get,put,remove 等常用操作只锁当前需要用到的桶。这样,原来只能一个线程进入,现在却能同时16个写线程执行,并发性能的提高是显而易见的。
另外 ConcurrentHashMap 使用了一种不同的迭代方式。在这种迭代方式中,当 iterator 被创建后集合再发生改变就不再是抛出 ConcurrentModificationException,取而代之的是在改变时 new 新的数据从而不影响原有的数据,iterator 完成后再将头指针替换为新的数据,这样 iterator 线程可以使用原来老的数据,而写线程也可以并发的完成改变。

5、CopyOnWriteArrayList 可以用于什么应用场景?

CopyOnWriteArrayList(免锁容器)的好处之一是当多个迭代器同时遍历和修改这个列表时,不会抛出 ConcurrentModificationExcption。 在 CopyOnWriteArrayList 中,写入将导致创建整个底层数据的副本,而原数据将保留在原地,使得复制的数据在被修改时,读取操作可以安全地执行。
由于写操作的时候,需要拷贝数组,会消耗内存,如果原数组的内容较多的情况下,可能导致 young gc 或者 full gc。
不能用于实时读的场景,想拷贝数组、新增元素都需要时间,所以调用一个 set 操作后,读取到数据可能还是旧的,虽然 CopyOnWriteArrayList 能做到最终一致性,但是还是无法满足实时性要求。

CopyOnWriteArrayList 透露的思想:
读写分离,读和写分开
最终一致性
使用另外开辟空间的思路,来解决并发冲突。

6、什么叫线程安全?servlet 是线程安全的吗?

线程安全是编程中的术语,指某个函数、函数库在多线程环境中被调用时,能够正确地处理多个线程之间的共享变量,使程序功能正确完成。
Servlet 不是线程安全的。servlet 是单实例多线程的。当多个线程同时访问同一个方法,是不能保证共享变量的线程安全的。
Struts2 的 action 是多实例多线程的,是线程安全的,每个请求过来都会 new 一个新的 action 分配给这个请求,请求完成后销毁。
SpringMVC 的 Controller 是线程安全的吗?不是的,和 Servlet 类似的处理流程。
Struts 好处是不用考虑线程安全的问题;Servlet 和 SpringMVC 需要考虑线程安全问题,但是性能可以提升不用处理太多的 gc,可以使用 ThreadLocal 来处理多线程的问题。 

7、volatile 有什么用?能否用一句话说明下 volatile 的应用场景?

volatile 保证内存可见性和禁止指令重排。
volatile 用于多线程环境下的单次操作(单次读或者单次写)。

8、为什么代码会重排序?

在执行程序时,为了提供性能,处理器和编译器常常会对指令进行重排序,但是不能随意重排序,不是你想怎么排序就怎么排序,它需要满足以下两个条件:
在但线程环境下不能改变程序运行的结果;
存在数据依赖关系的不允许重排序。
需要注意的是:重排序不会影响单线程环境的执行结果,但是会破坏多线程的执行语义。

9、在 java 中 wait 和 sleep 方法的不同?

最大的不同是在等待 wait 会释放锁,而 sleep 一直持有锁。Wait 通常被用于线程间交互,sleep 通常被用于暂停执行。

在 Java 中线程的状态一共被分成6种:
初始态:NEW
创建一个 Thread 对象,但还未调用 start()启动线程时,线程处于初始态。
运行态:RUNNABLE
在 Java 中,运行态包括就绪态和运行态。
就绪态该状态下的线程已经获得执行所需的所有资源,只要 CPU 分配执行权就能运行。所有就绪态的线程存放在就绪队列中。
运行态获得 CPU执行权,正在执行的线程。由于一个 CPU 同一时刻只能执行一条线程,因此每个 CPU 每个时刻只有一条运行态的线程。
阻塞态
当一条正在执行的线程请求某一资源失败时,就会进入阻塞态。而在 Java 中,阻塞态专指请求锁失败时进入的状态。由一个阻塞队列存放所有阻塞态的线程。处于阻塞态的线程会不断请求资源,一旦请求成功,就会进入就绪队列,等待执行。PS:锁、IO、Socket等都属于资源。
等待态“
当前线程中调用 wait、join、park 函数时,当前线程就会进入等待态。也有一个等待队列存放

1、什么是阻塞队列?阻塞队列的实现原理是什么?如何使用阻塞队列来实现生产者-消费者模型?

阻塞队列是一个支持两个附加操作的队列。
这两个附加的操作是:队列为空时,获取元素的线程会等待队列变为非空。当队列满时,存储元素的线程会等待队列可用。
阻塞队列常用于生产者和消费者的场景,生产者时往队列里添加元素的线程,消费者时从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器,而消费者也只从容器中拿元素。

JDK7 提供了7个阻塞队列。分别是:ArrayBlockingQueue:一个由数据结构组成的有界阻塞队列。
LinkedBlockingQueue:一个由链表结构组成的有界阻塞队列。
PriorityBlockingQueue:一个支持优先级排序的无界阻塞队列。
DelayQueue:一个使用优先级队列实现的无界阻塞队列。
SynchronousQueue:一个不存储元素的阻塞队列。
LinkedTransferQueue:一个由链表结构组成的无界阻塞队列。
LinkedBlockingDeque:一个由链表结构组成的双向阻塞队列。

Java5 之前实现同步存取时,可以使用普通的一个集合,然后在使用线程的协作和线程同步可以实现生产者,消费者模式,主要的技术就是用好 wait,notify,notifyAll,sychronized 这些关键字。而在 Java5 之后,可以使用阻塞队列来实现,此方法大大减少了代码量,使得多线程编程更加容易,安全方面也有保障。

BlockingQueue 接口时 Queue 的子接口,它的主要用途并不是作为容器,而是作为线程同步的工具,因此他具有一个很明显的特性,当生产者线程试图向 BlockingQueue 放入元素时,如果队列已满,则线程被阻塞,当消费者试图从中取出一个元素时,如果队列为空,则该线程会被阻塞,正是因为他所具有这个特性,所以在程序中多个线程交替向 BlockingQueue 中放入元素,取出元素,它可以很好的控制线程之间的通信。

阻塞队列使用最经典的场景就是 socket 客户端数据的读取和解析,读取数据的线程不断将数据放入队列,然后解析线程不断从队列取数据解析。

2、java中有几种方法可以实现一个线程?

继承 Thread 类
实现 Runnable() 接口
实现 Callable 接口,需要实现的是 call() 方法

3、什么是 Callable 和 Future?

Callable 接口类似于 Runnable,从名字就可以看出来了,但是 Runnable 不会返回结果,并且无法抛出返回结果的异常,而 Callable 功能更强大一些,被线程执行后,可以返回值,这个返回值可以被 Future 拿到,也就是说,Future可以拿到异步执行任务的返回值。
可以认为是带有回调的 Runnable。
Funture 接口表示异步任务,是还没有完成的任务给出的未来结果。所以说,Callable 用于产生结果,Future 用于获取结果。

4、什么是 FutureTask?使用 ExecutorService 启动任务。

在 Java 并发程序中 FutureTask 表示一个可以取消的异步运算。它有启动和取消运算、查询运算是否完成和取回返回结果等方法。只有当运算完成的时候结果才能取回,如果运算尚未完成 get 方法将会阻塞。一个 FutureTask 对象可以对调用了 Callable 和 Runnable 的对象进行包装,由于 FutureTask 也是调用了 Runnable 接口,所以它可以提交给 Executor 来执行。

5、什么是并发容器的实现?

何为同步容器:可以简单地理解为通过 synchronized 来实现同步的容器,如果有多个线程调用同步容器的方法,它们将会串行执行。比如 Vector, Hashtable 以及 Collections.synchronizedSet,synchronizedList 等方法返回的容器。可以通过查看 Vector,Hashtable 等这些同步容器的实现代码,可以看到这些容器实现线程安全的方式就是将他们的状态封装起来,并在需要同步的方法上加上关键字 synchronized。

并发容器使用了与同步容器完全不同的加锁策略来提供更高的并发行和伸缩性,例如在 ConcurrentHashMap 中采用了一种粒度更细的加锁机制,可以称为分段锁,在这种锁机制下,允许任意数量的读线程并发地访问 map,并且执行读操作的线程和写操作的线程也可以并发的访问 map,同时允许一定数量的写操作线程并发地修改 map,所以它可以在并发环境下实现更高的吞吐量。

6、多线程同步和互斥有几种实现方法,都是什么?

线程同步是指线程之间所具有的一种制约关系,一个线程的执行依赖于另一个线程的消息,当它没有得到另一个线程的消息时应等待,直到消息到达时才被唤醒。

线程互斥是指对于共享的进程系统资源,在各单个线程访问时的排他性。当有若干个线程都要使用某一共享资源时,任何时刻最多只允许一个线程去使用,其他要使用该资源的线程必须等待,直到占用资源者释放该资源。线程互斥可以看成是一种特殊的线程同步。
线程间的同步方法大体可分为两类:用户模式和内核模式。顾名思义,内核模式就是指利用系统内核对象的单一性进行同步,使用时需要切换内核态和用户态,而用户模式就是不需要切换到内核态,只在用户态完成操作。

用户模式下的方法有:原子操作(例如一个单一的全局变量),临界区。内核模式下的方法有:事件、信号量、互斥量。

7、什么是竞争条件?你怎样发现和解决竞争?

当多个进程都企图对共享数据进行某种处理,而最后的结果又取决于进程运行的顺序时,则我们认为这发生了竞争条件。

8、你将如何使用 thread dump?你将如何分析 thread dump?
![]()

新建状态(New)
用 new 语句创建的线程处于新建状态,此时他和其他 Java 对象一样,仅仅在 堆区 中被分配了内存。

就绪状态(Runnable)
当一个线程对象被创建后,其他线程调用它的 start() 方法,该线程就进入就绪状态,Java 虚拟机会为他创建 方法调用栈和程序计数器。处于这个状态的线程位于可运行池中,等待获得 CPU 的使用权。

运行状态(Running)
处于这个状态的线程占用 CPU,执行程序代码。只有处于就绪状态的线程才有机会转到运行状态。

阻塞状态(Blocked)
阻塞状态是指线程因为某些原因放弃 CPU,暂时停止运行。当线程处于阻塞状态时,Java虚拟机不会给线程分配 CPU。直到线程重新进入就绪状态,它才有机会转到运行状态。
阻塞状态可分为以下3种:
位于对象等待池中的阻塞状态(Blocked in object‘s wait pool):当线程处于运行状态时,如果执行了某个对象的 wait()方法,Java虚拟机就会把线程放到这个对象的等待池中,这涉及到“线程通信”的内容。
位于对象锁池中的阻塞状态(Blocked in object’s lock pool):当线程处于运行状态时,试图获得某个对象的同步锁时,如果该对象的同步锁已经被其他进程占用,Java虚拟机就会把这个线程放到这个对象的锁池中,这涉及到“线程同步”的内容。
其他阻塞状态(Otherwise Blocked):当前线程执行了 sleep() 方法,或者调用了其他线程的 join() 方法,或者发生了 I/O请求 时,就会进入这个状态。

死亡状态(Dead)
当线程退出 run() 方法时,就进入死亡状态,该线程结束生命周期。

9、为什么我们调用 start() 方法时会执行 run() 方法,为什么我们不能直接调用 run() 方法?

当你调用 start() 方法时你将创建新的线程,并且执行在 run() 方法里的代码。
但是如果你直接调用 run() 方法,他不会创建新的线程也不会执行调用线程的代码,只会把 run方法 当作普通方法去执行。

10、Java 中你怎样唤醒一个阻塞的线程?

在 Java 发展史上曾经使用 suspend()、resume() 方法对于线程进行阻塞唤醒,但随之出现很多问题,比较经典的还是死锁问题。
解决方案可以 使用以对象为目标的阻塞。即利用 Object 类的 wait() 和 notify() 方法实现线程阻塞。
首先,wait、notify 方法是针对对象的,调用任意对象的 wait() 方法都将导致线程阻塞,阻塞的同时也将释放该对象的锁,相应地,调用任意对象的 notify() 方法则将随机解除该对象阻塞的线程,但他需要重新获取对象的锁,直到获取成功才能往下执行;其他,wait、notify 方法必须在 synchronized块 或 方法中被调用,并且要保证同步块或方法的 锁对象 与调用 wait、notify 方法的对象是同一个,如此一来在调用 wait 之前当前线程就已经成功获取某对象的锁,执行 wait 阻塞后当前线程就将之前获取的对象锁释放。

11、在 Java 中 CyclicBarriar 和 CountdownLatch 有什么区别?

CyclicBarrier 可以重复使用,而 CountdownLatch 不能重复使用。

Java 的 concurrent 包里面的 CountdownLatch 其实可以把它看作一个计数器,只不过这个计数器的操作是原子操作,同时只能有一个线程去操作这个计数器,也就是同时只能有一个线程去减这个计数器里面的值。
你可以向 CountDownLatch 对象设置一个初始的数字作为计数值,任何调用这个对象的 await() 方法都会阻塞,直到这个计数器的计数值被其他的线程减为0为止。
所以在当前计数到达零之前, await 方法会一直受阻塞。之后,会释放所有等待的线程,await 的所有后续调用都将立即返回。这种现象只出现一次——计数器无法被重置。如果需要重置计数,请考虑使用 CyclicBarrier。
CoutDownLatch 的一个非常经典的应用场景是:有一个任务想要往下执行,但必须要等到其他的任务执行完毕后才可以继续往下执行。假如我们这个想要继续往下执行的任务调用一个 CountDownLatch 对象的 countDown() 方法,这个调用 await() 方法的任务将一直阻塞等待,直到这个 CountDownLatch 对象的计数值减到0为止。
CyclicBarrier 一个同步辅助类,它允许一组线程相互等待,直到到达某个公共屏障点(common barrier point)。在涉及一组固定大小的线程的程序中,这些线程必须不时地相互等待,此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用,所以称它为循环的 barrier。 

12、什么是不可变对象,它对写并发应用有什么帮助?

不可变对象(Immutable Objects)即对象一旦被创建他的状态(对象的数据,也即对象属性值)就不能改变,反之即为可变对象(Mutable Objects)
不可变对象的类即为不可变类。Java 平台类库中包含许多不可变类,如 String、基本类型的包装类、BigInteger 和 BigDecimal 等。
不可变对象天生是线程安全的。他们的常量(域)是在构造函数中创建的。既然他们的状态无法改变,这些常量永远不会变。
不可变对象永远是线程安全的。

只有满足如下状态,一个对象才是不可变的:
他的状态不能在创建后再被修改。
所有的域都是 final 类型。
他被正确创建(创建期间没有发生 this 引用的溢出)。

13、如何停止一个正在运行的线程?

使用共享变量的方式
在这种方式中,之所以引入共享变量,是因为该变量可以被多个执行相同任务的线程用来作为是否中断的信号,通知中断线程的执行。

使用 interrupt 方法终止线程
如果一个线程由于等待某些事件的发生而被阻塞,又该怎么停止该线程呢?这种情况经常会发生,比如当一个线程由于需要等候键盘输入而被阻塞,或者调用 Thread.join() 方法,或者 Thread.sleep() 方法,在网络中调用 ServerSocket.accept() 方法,或者调用了 DatagramSocket.receive() 方法时,都有可能导致线程阻塞,使线程处于不可运行状态,即使主程序中将该线程的共享变量设置为 true,但该线程此时根本无法检查循环标志,当然也就无法立即中断。这里我们给出的建议是,不要使用 stop() 方法,而是使用 Thread 提供的 interrupt() 方法,因为该方法虽然不会中断一个正在运行的进程,但是它可以使一个被阻塞的线程提前结束阻塞状态,退出阻塞代码。

14、java 如何实现多线程之间的通讯和协作?

中断和共享变量

15、notify() 和 notifyall() 有什么区别?

当一个线程进入 wait 之后,就必须等其他线程 notify/notifyall,使用 notifyall 可以唤醒所有处于 wait 状态的线程,使其重新进入锁的争夺队列中,而 notify 只能唤醒一个。

如果没把握,建议 notifyAll,防止 notify 因为信号丢失而造成程序异常。

1、什么是 Daemon 线程?它有什么意义?

所谓后台(daemon)线程,是指在程序运行的时候在后台提供一种通用服务的线程,并且这个线程并不属于程序不可或缺的部分。因此,当所有的非后台线程结束时,程序也就终止了,同时会杀死进程中的所有后台线程。
反过来说,只要有任何非后台线程还在运行,程序就不会终止。必须在线程启动之前调用 setDaemon() 方法,才能把它设置为后台线程。
注意:后台进程在不执行 finally 子句的情况下就不会终止其 run() 方法。
比如:JVM 的垃圾回收线程就是 Daemon线程,Finalizer 也是守护线程。

2、、如何创建守护线程?

3、在 Java 中守护线程和本地线程区别?

java 中的线程分为两种:守护线程和用户线程。
任何线程都可以设置为守护线程和用户线程,通过方法 Thread.setDaemon(bool on);true 则把该线程设置为守护线程,反之为用户线程。Thread.setDaemon() 必须在 Thread.start() 之前调用,否则运行时会抛出异常。

两者的区别:
唯一的区别是判断虚拟机(JVM)何时离开,Daemon 是为其它线程提供服务,如果全部的 User Thread 已经撤离,Daemon 没有客服务的线程,JVM 撤离。也可以理解为守护线程是 JVM 自动创建的线程(但不一定),用户线程是程序创建的线程;比如 JVM 的垃圾回收线程是一个守护线程,当所有的线程已经撤离,不再产生垃圾,守护线程自然就没事可干了,当垃圾回收线程是 Java 虚拟机上仅剩的线程时,Java 虚拟机会自动离开。

扩展:Thread Dump 打印出来的线程信息, 含有 daemon 字样的线程即为守护线程,可能会有:服务守护进程、编译守护进程、windows下的监听 Ctrl+break 的守护进程,Finalizer守护进程、引用处理守护进程、GC守护进程。

2、线程与进程的区别?

进程是操作系统分配资源的最小单元,线程是操作系统调度的最小单元。
一个程序至少有一个进程,一个进程至少有一个线程。

3、什么是多线程中的上下文切换?

多线程会共同使用一组计算机上的CPU,而线程数大于给程序分配的CPU数量时,为了让各个线程都有执行的机会,就需要轮转使用CPU。不同的线程切换使用CPU发生的切换数据等就是上下文切换。

在上下文切换过程中,CPU 会停止处理当前运行的程序,并保存当前程序运行的具体位置以便之后继续运行。从这个角度来看,上下文切换有点像我们同时阅读几本书,在来回切换书本的同时我们需要记住每本书当前读到的页码。在程序中,上下文切换过程中的“页码”信息是保存在进程控制块(PCB)中的。PCB 还经常被称作“切换帧”(switchframe)。“页码”信息会一直保存到 CPU 的内存中,直到他们被再次使用。
上下文切换是存储和恢复 CPU 状态的过程,它使得线程执行能够从中断点恢复执行。上下文切换是多任务操作系统和多线程环境的基本特征。

4、死锁与活锁的区别,死锁与饥饿的区别?

死锁:是指两个或两个以上的进程(或线程)在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,他们都将无法推进下去。

产生死锁的必要条件:互斥条件:所谓互斥就是进程在某一时间内独占资源。
请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。
不剥夺条件:进程已获得资源,在未使用完之前,不能强行剥夺。
循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

活锁:任务或者执行者没有被阻塞,由于某些条件没有满足,导致一直重复尝试,失败,尝试,失败。

活锁和死锁的区别在于,处于活锁的实体是在不断的改变状态,所谓的“活”,而处于死锁的实体表现为等待;活锁有可能自行解开,死锁则不能。

饥饿:一个或者多个线程因为种种原因无法获得所需要的资源,导致一直无法执行的状态。

Java 中导致饥饿的原因:高优先级线程吞噬所有的低优先级线程的 CPU时间。
线程被永久堵塞在一个等待进行同步块的状态,因为其他线程总能在它之前持续地对该同步块进行访问。
线程在等待一个本身也处于永久等待完成的对象(比如调用这个对象的 wait方法),因为其他线程总是被持续地唤醒。

5、Java 中用到的线程调度算法是什么?

采用时间片轮转的方式。可以设置线程的优先级,会映射到下层的系统上面的优先级上,如非特别需要,尽量不要用,防止线程饥饿。

计算机通常只有一个 CPU,在任意时刻只能执行一条机器指令,每个线程只有获得 CPU 的使用权才能执行指令。所谓多线程的并发运行,其实是指从宏观上看,各个线程轮流获得 CPU 的使用权,分别执行各自的任务。在运行池中,会有多个处于就绪状态的线程在等待 CPU,Java 虚拟机的一项任务就是负责线程的调度,线程调度是指按照特定机制为多个线程分配 CPU 的使用权。

有两种调度模型:分时调度模型 和 抢占式调度模型。

分时调度模型是指让所有的线程轮流获得 cpu 的使用权,并且平均分配每个线程占用 cpu 的时间片。

Java虚拟机采用抢占式调度模型,是指优先让可运行池中优先级高的线程占用 CPU,如果可运行池中的线程优先级相同,那么就随机选择一个线程,使其占用 CPU。处于运行状态的线程会一直运行,直至他不得不放弃 CPU。

6、什么是线程组,为什么在 Java 中不推荐使用?

ThreadGroup类,可以把线程归属到某一个线程组中,线程组中可以有线程对象,也可以有线程组,组中还可以有线程,这样的组织结构有点类似于树的形式。
为什么不推荐使用?因为你使用有很多的安全隐患吧,没有具体追究,如果需要使用,推荐使用线程池。

线程组和线程池是两个不同的概念,他们的作用完全不同,前者是为了方便线程的管理,后者是为了管理线程的生命周期,复用线程,减少创建销毁线程的开销。

7、为什么使用 Executor 框架比使用应用创建和管理线程好?

为什么使用 Executor 线程池框架
每次执行任务创建线程 new Thread() 比较消耗性能,创建一个线程是比较耗时、耗资源的。
调用 new Tread() 创建的线程缺乏管理,被称之为野线程,而且可以无限制地创建,线程之间的相互竞争会导致过多占用系统资源而导致系统瘫痪,还有线程之间的频繁交替也会消耗很多系统资源。
直接使用 new Thread() 启动的线程不利于扩展,比如定时执行、定期执行、定时定期执行、线程中断等都不便实现。

使用 Executor 线程池框架的优点
能复用已存在并空闲的线程从而减少线程对象的创建从而减少了消亡线程的开销。
可有效控制最大并发线程数,提高系统资源使用率,同时避免过多资源竞争。
框架中已经有定时、定期、单线程、并发数控制等功能。

综上所述使用线程池框架Executor能更好的管理线程、提高系统资源使用率。

8、在 Java 中 Executor 和 Executors 的区别?

Executors 工具类的不同方法按照我们的需求创建了不同的线程池,来满足业务的需要。
Executor 接口对象能执行我们的线程任务。
ExecutorService 接口继承了 Executor 接口并进行了扩展,提供了更多的方法,我们能获得任务执行的状态并且可以获取任务的返回值。
使用 ThreadPoolExecutor 可以创建自定义线程池。
Future 表示异步计算的结果,它提供了检查计算是否完成的方法,以等待计算的完成,并可以使用 get()方法 获取计算的结果。

9、什么是 Executors 框架?

Executor 框架是一个根据一组执行策略调用,调度,执行和控制的异步任务的框架。
无限制的创建线程会引起应用程序内存的溢出。所以创建一个线程池是个更好的解决方法,因为可以限制线程的数量并且可以回收再利用这些线程。利用 Executors 框架可以非常方便的创建一个线程池。

10、什么是原子操作?在 Java Concurrency API 中有哪些原子类?

原子操作意为”不可被中断的一个或一系列操作“。
处理器使用基于 对缓存加锁 或 总线加锁 的方式来实现 多处理器之间的原子操作。
在 Java 中可以通过 锁 和 循环CAS 的方式来实现原子操作。CAS操作 —— Compare & Set,或是 Compare & Swap,现在几乎所有的 CPU指令 都支持 CAS 的原子操作。
原子操作是指一个不受其他操作影响的操作任务单元。原子操作是在多线程环境下避免数据不一致必须的手段。
int++ 并不是一个原子操作,所以当一个线程读取它的值并加1时,另外一个线程有可能会读到之前的值,这就会引发错误。
为了解决这个问题,必须保证增加操作是原子的,在 JDK1.5之前我们可以使用同步技术来做到这一点。到 JDK1.5, java.util.concurrent.atomic 包提供了 int 和 long 类型的原子包装类,它们可以自动的保证对于他们的操作是原子的并且不需要使用同步。
java.util.concurrent 这个包里面提供了一组原子类。其基本的特性就是在多线程环境下,当有多个线程同时执行这些类的实例包含的方法时,具有排他性,即当某个线程进入方法,执行其中的指令时,不会被其他线程打断,而别的线程就像自旋锁一样,一直等到该方法执行完成,才由 JVM 从等待队列中选择另一个线程进入,这只是一种逻辑上的理解。

原子类:AtomicBoolean,AtomicInteger,AtomicLong,AtomicReference
原子数组:AtomicIntegerArray,AtomicLongArray,AtomicReferenArray
原子属性更新器:AtomicLongFieldUpdater,AtomicIntegerFieldUpdater,AtomicReferenceFieldUpdater
解决 ABA 问题的原子类:AtomicMarkableReference(通过引入一个 boolean 来反映中间有没有变过),AtomicStampedReference(通过引入一个 int 累加来反应中间有没有变过)。

10.1 ABA问题

11、Java Concurrency API 中的 Lock 接口是什么?对比同步他有什么优势?

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

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

整体上来说 Lock 是 synchronized 的扩展版, Lock 提供了无条件的、可轮询的(tryLock 方法)、定时的(tryLock 带参方法)、可中断的(lockInterruptibly)、可多条件队列的(newCondition 方法)锁操作。另外 Lock 的实现类基本都支持非公平锁(默认)和公平锁,synchronized 只支持非公平锁,当然,在大部分情况下,非公平锁是高效的选择。

1、为什么要尽量设定一个主键?

主键是数据库确保数据行在整张表唯一性的保障,即使业务上本张表没有主键,也建议添加一个自增长的ID列作为主键。
设定了主键之后,在后续的删改查的时候可能更加快速以及确保操作数据范围安全。

2、主键使用自增ID还是UUID?

UUID 是指Universally Unique Identifier,翻译为中文是通用唯一识别码,UUID 的目的是让分布式系统中的所有元素都能有唯一的识别信息。如此一来,每个人都可以创建不与其它人冲突的 UUID,就不需考虑数据库创建时的名称重复问题。
推荐使用自增ID,不要使用UUID。
因为在InnoDB存储引擎中,主键索引是作为聚簇索引存在的,也就是说,主键索引的B+树叶子节点上存储了主键索引以及全部的数据(按照顺序),如果主键索引是自增ID,那么只需要不断向后排列即可,如果是UUID,由于到来的ID与原来的大小不确定,会造成非常多的数据插入,数据移动,然后导致产生很多的内存碎片,进而造成插入性能的下降。
总之,在数据量大一些的情况下,用自增键性能会好一些。
关于主键是聚簇索引,如果没有主键,InnoDB会选择一个唯一键来作为聚簇索引,如果没有唯一键,会生成一个隐式的主键。

3、字段为什么要求定义为not null?

null值会占用更多的字节,且会在程序中造成很多与预期不符的情况。

4、如果要存储用户的密码散列,应该使用什么字段进行存储?

密码散列,盐,用户身份证号等固定长度的字符串应该使用char而不是varchar来存储,这样可以节省空间且提高检索效率。

[参考:码匠笔记]