在Java的集合类中,有些是同步不安全的,如HashMap,有些是同步安全的,如HashTable,Vector。
查看源码会发现,这些所谓同步安全的集合,其实现方式 就是 通过在某些方法上,如add,增加synchronized修饰。然后同步就实现了。
同步是什么,同步就是排队,比如公共电话亭打电话,一个电话,现在来了3个人,同步就是说第一个人打完了,第二个人再上,之后第三个人再上。
需要同步的原因是因为有并发,有多个线程,单线程永远没有同步的问题,那本身就是同步的。
多线程也未必就有同步的需要,当众多线程 对于 观察对象,不进行干扰的话,并发也不需要同步,比如看直播,1个人看直播,和10万人看直播,你们只是看的话,是没有并发问题的,不需要同步,只需要把直播画面,拷贝10万份给每个人就可以了。
但下面这种情况就有问题了,10个人在看一个主播直播,其中3个人希望主播换一首歌,换成自己喜欢的,如果这三个请求同时提出,那么主播该怎么办。
如果三首同时放,那不可能,也没法听。
如果随便忽略掉请求,也不算完美的解决办法。
最后的办法只能是 把并行的需求,串行化,一个一个来。
所以同步说白一点,就是排队,一个一个来。
那一个一个来有什么问题呢? 这不又成单线程了吗
所以这其中的问题是
1,单线程,正确,但一个一个来,处理的太慢。
2,多线程,并发,同时做,肯定速度快,但某些点上,有可能出现错误。
同步就要求,即快,又正确。这就是难点,难在,需要分析出,
在这件事情中,哪些区域是可以并发,也不会出问题的,哪些区域是不能并发,还是要排队的。
所以同步就是 多线程+单线程的组合。
用关键字synchronized,首先要分析出,要对谁进行同步,先看个错误例子,这里面用了synchronized,还是没有达到同步的效果。
class Task implements Runnable{
synchronized void add(){
int tmp = TestMain.i;
tmp = tmp + 1;
TestMain.i = tmp;
}
public void run() {
//每个线程会增加50次
for(int i=0;i<50;i++){
add();
}
}
}
public class TestMain {
static int i=0;
static Object o = new Object();
public static void main(String[] args) throws InterruptedException {
// 创建100个线程
for(int i=0;i<100;i++){
Thread t = new Thread(new Task());
t.start();
}
Thread.sleep(1000);
System.out.println(i);
}
}
某一次输出为
4969
这个程序会创建100个线程,每个线程执行的任务是 对 变量i增加50次, 所以我期望的结果,i最后变成5000了,但事与愿违
这个程序基本每次输出都不一样,但都小于5000.
原因就处在add()方法上, 但我已经给这个方法 加上synchronized关键字了,为什么还是同步不了呢?
这个问题困扰了我很久,直到---
因为我没搞明白一个问题,synchronized是给谁加锁的。
锁在哪儿, Java中,每个对象都是锁,包括实例出来的对象,类本身。
现在回头看这个程序, 我把synchronized加再一个 普通方法上, 这时 锁就是 实例化的Task对象, 它能实现的效果是, 多个线程,在操作这个实例的 add方法时,保证它们是排队进行的。
可我的程序中
Thread t = new Thread(new Task()); 这段代码, 在创建每个线程时,都新创建 了一个 新的Task实例, 等于是100个线程,创建了100把锁,足球场100个人,发了100个球,各玩各的,根本不同竞争。 那么怎么修改呢
简单,只创建一个 Task实例,给100个线程去玩,到时候,自然会竞争add方法的, 代码修改如下
class Task implements Runnable{
synchronized void add(){
int tmp = TestMain.i;
tmp = tmp + 1;
TestMain.i = tmp;
}
public void run() {
//每个线程会增加50次
for(int i=0;i<50;i++){
add();
}
}
}
public class TestMain {
static int i=0;
static Object o = new Object();
public static void main(String[] args) throws InterruptedException {
//只创建一个Task ,然后传给100个线程。
Task task = new Task();
// 创建100个线程
for(int i=0;i<100;i++){
Thread t = new Thread(task);
t.start();
}
Thread.sleep(1000);
System.out.println(i);
}
}
输出
5000
输出5000, 符合预期。 这是synchronized的一种情况,对普通方法加锁,锁是该类实例后的 对象。
synchronized还有两种用法, 修饰静态方法, 和 修饰代码块。
下面的代码是 同步静态方法 的 例子,将原来的add方法改成static的了
class Task implements Runnable{
synchronized static void add(){
int tmp = TestMain.i;
tmp = tmp + 1;
TestMain.i = tmp;
}
public void run() {
//每个线程会增加50次
for(int i=0;i<50;i++){
add();
}
}
}
public class TestMain {
static int i=0;
static Object o = new Object();
public static void main(String[] args) throws InterruptedException {
//只创建一个Task ,然后传给100个线程。
// 创建100个线程
for(int i=0;i<100;i++){
Thread t = new Thread(new Task());
t.start();
}
Thread.sleep(1000);
System.out.println(i);
}
}
输出
5000 符合预期。
在这个例子中, 100个线程 创建了100个Task实例, 但并没有出现 并发的错误, 原因是 add是静态方法, 和具体的实例无关, 即使new100个实例,也是用的一个方法, synchronized修饰静态方法, 对应的锁是这个静态方法的类,所以 同步没有问题。
第三种情况, synchronized代码块
class Task implements Runnable{
void add(){
synchronized (Task.class) {
int tmp = TestMain.i;
tmp = tmp + 1;
TestMain.i = tmp;
}
}
public void run() {
//每个线程会增加50次
for(int i=0;i<50;i++){
add();
}
}
}
public class TestMain {
static int i=0;
static Object o = new Object();
public static void main(String[] args) throws InterruptedException {
// 创建100个线程
for(int i=0;i<100;i++){
Thread t = new Thread(new Task());
t.start();
}
Thread.sleep(1000);
System.out.println(i);
}
}
这次add还是普通方法,而add的函数体 都包含在 synchronized中,
这样写的时候, synchronized后面有个括号, 其中需要一个对象,也就是锁, 这样的好处是 这个锁可以根据需要, 传不同的对象,前面两种方式 一个是 所在实例的作为锁,一个是所在类作为锁,有些不灵活, 第三种方法,你可以将任何对象传进来,这其实是为了 缩小锁定的范围。
毕竟锁定和多线程是矛盾的。一定要选择合适的 同步范围 。
正确性是第一优先的, 如果程序无法保证正确,那就无法使用,
在保证正确性的前提下, 缩小锁定的范围, 提高程序的整体效率,是追求的目标。
网友评论