线程安全
线程安全
如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。
线程同步
当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。为了保证每个线程都能正常执行原子操作（原子性），Java中提供了同步机制(synchronized)来解决。
窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。
有三种方式完成同步操作：
-
同步代码块。
-
同步方法。
-
锁机制。
同步代码块
synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
synchronized(同步锁){
需要同步操作的代码
}
同步锁（任何一个对象都可以作为同步锁（Object））:
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.
- 锁对象 可以是任意类型。
- 多个线程对象 要使用同一把锁。
在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED锁阻塞)。
同步方法(底层也是同步代码块)
使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
public synchronized void method(){
可能会产生线程安全问题的代码
}
同步方法的同步锁是谁?
对于非static方法,同步锁就是this。
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。
Lock锁（接口）
java.util.concurrent.locks。Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。
Lock锁也称同步锁，加锁与释放锁方法化了
- public void lock() ：加同步锁。
- public void unlock() ：释放同步锁。
public class TicketThread implements Runnable{
private int ticket = 100;
Object obj = new Object();
Lock lock = new ReentrantLock();
@Override
public void run() {
//不使用线程同步，线程是不安全的，但是效率高
/*while(true){
if(ticket>0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在卖："+ticket--);
}else{
break;
}
}*/
/*发现程序出现了两个问题：
1. 相同的票数,比如5这张票被卖了两回。
2. 不存在的票，比如0票与-1票，是不存在的。
这种问题，几个窗口(线程)票数不同步了，这种问题称为线程不安全*/
//使用同步代码块
/*synchronized (obj){
while(true){
if(ticket>0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在卖："+ticket--);
}else{
break;
}
}*/
//使用同步方法
// ticketSell();
//使用lock锁
while(true){
lock.lock();
if(ticket>0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在卖："+ticket--);
}else{
break;
}
lock.unlock();
}
}
public synchronized void ticketSell(){
while(true){
if(ticket>0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在卖："+ticket--);
}else{
break;
}
}
}
}
public class TicketDemo {
public static void main(String[] args) {
TicketThread ticketThread = new TicketThread();
Thread thread = new Thread(ticketThread,"zero");
Thread thread1 = new Thread(ticketThread,"one");
Thread thread2 = new Thread(ticketThread,"two");
thread.start();
thread1.start();
thread2.start();
}
}
为什么会出现线程安全问题？
多个线程同时操作（写操作）同一个共享资源，有可能出现线程安全问题（重复卖票、卖不存在票）
怎样解决线程安全问题？
同步代码块。
同步方法。
锁机制。
线程安全，效率低，线程不安全，效率高
如何抉择安全与效率的问题：
如果需要操作共享资源，对共享资源有写的操作，需要考虑线程安全，从而舍弃效率问题，若不涉及多线程或者涉及多线程，但不涉及多线程，或者不对共享资源进行写的操作可以不考虑线程安全问题。
线程状态
当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。
| 线程状态 | 导致状态发生条件 |
|---|---|
| NEW(新建) | 线程刚被创建，但是并未启动。还没调用start方法。 |
| Runnable(可运行) | 调用start方法以后，线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。 |
| Blocked(锁阻塞) | 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。 |
| Waiting(无限等待) | 一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。 |
| Timed Waiting(计时等待) | 同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。 |
| Teminated(被终止) | 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡 |
Timed Waiting（计时等待）
一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。
当我们调用了sleep方法之后，当前执行的线程就进入到“休眠状态”，其实就是所谓的Timed Waiting(计时等待)
-
进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法，单独的线程也可以调用，不一定非要有协作关系。
-
为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程中会睡眠
-
sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。
sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始立刻执行
BLOCKED（锁阻塞）
一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。（线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。）
Waiting（无限等待）
一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。
一个调用了某个对象的 Object.wait 方法的线程会等待另一个线程调用此对象的Object.notify()方法 或 Object.notifyAll()方法。
其实waiting状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁，同时相互之间又存在协作关系。
当多个线程协作时，比如A，B线程，如果A线程在Runnable（可运行）状态中调用了wait()方法那么A线程就进入了Waiting（无限等待）状态，同时失去了同步锁。假如这个时候B线程获取到了同步锁，在运行状态中调用了notify()方法（wait会释放锁，notify仅仅只是通知，不释放锁），那么就会将无限等待的A线程唤醒。注意是唤醒，如果获取到锁对象，那么A线程唤醒后就进入Runnable（可运行）状态；如果没有获取锁对象，那么就进入到Blocked（锁阻塞状态）。
Object.wait(1000);Thread.sleep(1000);计时等待
wait、notify及notifyAll属于线程的操作，为何不把他们放到线程Thread类中，而放在Object中？
因为休眠唤醒，wait、notify及notifyAll都是通过锁对象来操作，而任何对象都可以用来充当锁对象，而所有对象都直接或间接的继承Object类，所以在Object中更为合理。
补充：
StringBuffer 和 StringBuilder 的区别
线程安全
StringBuffer是线程安全的，而StringBuilder是线程不安全的，因为StringBuffer的所有公开方法都是synchronized修饰的，而StringBuilder并没有synchronized修饰。
缓冲区
可以看出，StringBuffer 每次获取toString都会直接使用缓存区的toStringCache值来构造一个字符串。而StringBuilder则每次都需要复制一次字符数组，再构造一个字符串。
性能
既然StringBuffer线程安全的，它的所有公开方法都是同步的，StringBuilder 没有对方法加锁同步的，所以无疑问，StringBuilder 的性能要远大于StringBuffer。
ArrayList，Vector的区别：
（1）：Vector是线程安全的，源码中有很多的synchronized可以看出，而ArrayList不是。导致Vector效率无法和ArrayList相比；
（2）：ArrayList和Vector都采用线性连续存储空间，当存储空间不足的时候，ArrayList默认增加为原来的50%，Vector默认增加为原来的一倍；
（3）：Vector可以设置capacityIncrement，而ArrayList不可以，从字面理解就是capacity容量，Increment增加，容量增长的参数。
扫一扫
136
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
