0037 Java学习笔记-多线程-同步代码块、同步方法、同步锁

什么是同步

  • 在上一篇0036 Java学习笔记-多线程-创建线程的三种方式示例代码中,实现Runnable创建多条线程,输出中的结果中会有错误,比如一张票卖了两次,有的票没卖的情况,因为线程对象被多条线程访问,一条线程在执行一个循环的过程中被中断,下一个线程则出现错误
  • 因此,线程任务中可能引起错误的地方应当被一次执行完毕

同步代码块

  • 用同步代码块改写上面的代码
package testpack;

public class Test1  {
public static void main(String[] args){
System.out.println("现在是主线程: "+Thread.currentThread());
System.out.println("下面新建两个线程");
A a=new A(500);
new Thread(a,"线程A").start();
new Thread(a,"线程B").start();
new Thread(a,"线程C").start();
}
}
class A implements Runnable{
private int tickets;
A (int tick){
tickets=tick;
}
private Object obj=new Object(); //同步监视器
public void run() {
synchronized(obj){ //同步代码块
for (;tickets>0;tickets--) {
System.out.println("当前线程:"+Thread.currentThread()+" 卖出第 "+tickets+" 张票。");
try{
Thread.sleep(1); //让当前线程暂停1毫秒,其他线程也不能执行该同步代码块
}catch(InterruptedException ex){
ex.printStackTrace();
}
if (tickets==1){
System.out.println("票已卖完,当前线程是: "+Thread.currentThread());
}
}
} }
}
  • 同步监视器,就是一个普通的对象,就像一把锁,只有获得了同步监视器的线程才能执行同步代码块。
  • 同步代码块执行一次完毕后,将会释放锁,接下来是这条线程拿到同步锁,还是其他其他线程,则不一定,根据线程调度而定,但是在同步代码块执行过程中,不会被中断,一个同步任务会被一次执行完毕

同步方法

  • 在同步代码块中,synchonized关键字在run()方法内部,修饰的是一段代码,也可以用来修饰run()方法,也就是同步方法
  • synchronized不只可以修饰run()方法,还可以修饰其他方法,只要是需要一次同步完成的任务,然后再在run()方法中被调用
  • 同步方法中有一个隐式的同步监视器,就是this,也就是调用run()方法(或同步方法)的这个对象
  • 还是上面的实例,用同步方法改写
package testpack;

public class Test1  {
public static void main(String[] args){
System.out.println("现在是主线程: "+Thread.currentThread());
System.out.println("下面新建两个线程");
A a=new A(500);
new Thread(a,"线程A").start();
new Thread(a,"线程B").start();
new Thread(a,"线程C").start();
}
}
class A implements Runnable{
private int tickets;
A (int tick){
tickets=tick;
}
public synchronized void run() { //同步方法
for (;tickets>0;tickets--) {
System.out.println("当前线程:"+Thread.currentThread()+" 卖出第 "+tickets+" 张票。");
try{
Thread.sleep(1);
}catch(InterruptedException ex){
ex.printStackTrace();
}
if (tickets==1){
System.out.println("票已卖完,当前线程是: "+Thread.currentThread());
}
} }
}

释放同步监视器

  • 当前线程的同步任务(同步方法、同步代码块)执行完毕
  • 在同步任务中,遇到break、return,终止了同步任务
  • 在同步任务中,出现Error、Exception等,导致同步任务结束
  • 在同步任务中,执行了同步监视器对象的wait()方法,则当前线程暂停,并释放同步监视器
  • 不会释放同步监视器的情况:
    • 同步任务中,调用Thread.sleep()、Thread.yield()方法来暂停当前线程的执行
    • 同步任务中,其他线程调用了该线程的suspend()方法将该线程挂起

同步锁

  • 除了可以用new Object()和this作同步监视器往外,还可以定义专门的同步锁,且功能更加强
  • Lock接口
    • ReentrantLock实现类
  • ReadWriteLock
    • ReentrantReadWriteLock实现类
    • ReentrantReadWriteLock.ReadLock
    • ReentrantReadWriteLock.WriteLock
  • StampedLock
  • 示例:用ReentrantLock改写上面的代码
package testpack;

import java.util.concurrent.locks.ReentrantLock;

public class Test1  {
public static void main(String[] args){
System.out.println("现在是主线程: "+Thread.currentThread());
System.out.println("下面新建两个线程");
A a=new A(50);
new Thread(a,"线程A").start();
new Thread(a,"线程B").start();
new Thread(a,"线程C").start();
}
}
class A implements Runnable{
private final ReentrantLock lock=new ReentrantLock(); //定义一个同步锁
private int tickets;
A (int tick){
tickets=tick;
}
public void run() {
lock.lock(); //加锁
for (;tickets>0;tickets--) {
System.out.println("当前线程:"+Thread.currentThread()+" 卖出第 "+tickets+" 张票。");
if (tickets==1){
System.out.println("票已卖完,当前线程是: "+Thread.currentThread());
}
}
lock.unlock(); //释放锁
}
}

死锁

  • 两个线程各拿一把锁,下一步运行都需要对方手里那把锁,但都拿不到,则造成死锁,程序不能继续执行
package testpack;
public class Test1 {
public static void main(String[] args){
DeadLock dl=new DeadLock();
new Thread(dl).start();
dl.init();
}
}
class DeadLock implements Runnable {
A a=new A();
B b=new B();
public void init(){
a.a1(b);
System.out.println("进入主线程");
}
public void run(){
b.b1(a);
System.out.println("进入子线程");
}
}
class A {
public synchronized void a1(B b){
System.out.println("当前线程是:"+Thread.currentThread().getName()+" ,正在执行a1()");
try{
Thread.sleep(10);
}catch(InterruptedException ex){
ex.printStackTrace();
}
System.out.println("当前线程是:"+Thread.currentThread().getName()+" ,准备调用b2()");
b.b2(); //b2方法是同步方法,调用该方法要对调用的对象b加锁
}
public synchronized void a2(){
System.out.println("这是a2()方法");
}
}
class B{ public synchronized void b1(A a){
System.out.println("当前线程是:"+Thread.currentThread().getName()+" ,正在执行b1()");
try{
Thread.sleep(10);
}catch(InterruptedException ex){
ex.printStackTrace();
}
System.out.println("当前线程是:"+Thread.currentThread().getName()+" ,准备调用a2()");
a.a2(); //a2方法是同步方法,调用该方法要对调用的对象a加锁
} public synchronized void b2(){
System.out.println("这是b2()方法");
}
}
  • 上面在调用a.a2()和b.b2()方法时,分别要对a对象和b对象加锁,但这时,a、b对象的锁都在对方手里,造成两个线程阻塞

其他

  • 可变类的线程安全是以降低程序的运行效率为代价的
  • 不要对线程安全类的所有方法都进行同步,只对那些改变共享资源的方法进行同步
  • 如果一个类有单线程和多线程运行环境,那么应该提供两种版本,就是StringBuilder(单线程)和StringBuffer(多线程)一样
上一篇:libsvm数据处理初略流程


下一篇:基础-ADO插入数据后返回自增ID @@IDENTITY