Java多线程

文章目录

- - synchronized同步方法
  - - 方法内的变量为线程安全
    - 实例变量为非线程安全
    - 多个对象多个锁
    - synchronized方法与锁对象
    - synchronized锁重入
    - 出现异常，锁自动释放
    - 同步不具有继承性
  - synchronized同步语句块
  - - synchronized同步语句块的使用
    - 将任意对象作为对象检测器
    - 细化验证三个结论

synchronized同步方法方法内的变量为线程安全

方法中的变量不存在非线程安全问题，永远都是线程安全的，这个是由于方法内部变量是私有的特性造成的。

实例变量为非线程安全

这个在上一节中提到过，解决的方法就是在相对应的方法前加上关键字synchronized即可。

多个对象多个锁

package multiply.com.test;
public class Run {
    public static void main(String[] args) {
        HasSelfPrivateNum numRef1 = new HasSelfPrivateNum();
        HasSelfPrivateNum numRef2 = new HasSelfPrivateNum();
        //设置了两个不同对象的两个线程，多个对象多个锁，两个线程就是异步运行的
        ThreadA aThread = new ThreadA(numRef1);
        ThreadB bThread = new ThreadB(numRef2);
        aThread.start();
        bThread.start();
    }
}

package multiply.com.test;
public class ThreadA extends Thread {
    private HasSelfPrivateNum numRef;
    public ThreadA(HasSelfPrivateNum numRef) {
        this.numRef = numRef;
    }
    @Override
    public void run() {
        super.run();
        numRef.addI("a");
    }
}

package multiply.com.test;
public class ThreadB extends Thread {
    private HasSelfPrivateNum numRef;
    public ThreadB(HasSelfPrivateNum numRef) {
        this.numRef = numRef;
    }
    @Override
    public void run() {
        super.run();
        numRef.addI("b");
    }
}

package multiply.com.test;
public class HasSelfPrivateNum {
    private int num = 0;
    public synchronized void addI(String username) {
        try {
            if ("a".equals(username)) {
                num = 100;
                System.out.println("a set over!");
                Thread.sleep(1600);
            } else {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(username + " num = " + num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

b set over!
a set over!
b num = 200
a num = 100
异步运行，不存在脏读的现象。

synchronized方法与锁对象

package multiply.com.test;
public class Run {
    public static void main(String[] args) {
        MyObject object = new MyObject();
        ThreadA aThread = new ThreadA(object);
        ThreadB bThread = new ThreadB(object);
        aThread.setName("A");
        bThread.setName("B");
        aThread.start();
        bThread.start();
    }
}

package multiply.com.test;
public class ThreadA extends Thread {
    private MyObject object;
    public ThreadA(MyObject object) {
        this.object = object;
    }
    @Override
    public void run() {
        super.run();
        object.methodA();
    }
}

package multiply.com.test;
public class ThreadB extends Thread {
    private MyObject object;
    public ThreadB(MyObject object) {
        this.object = object;
    }
    @Override
    public void run() {
        super.run();
        object.methodB();
    }
}

package multiply.com.test;
public class MyObject {
    public synchronized void methodA() {
        try {
            System.out.println("begin method A thread name = " + Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public void methodB() {
        try {
            System.out.println("begin method B thread name = " + Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

begin method B thread name = B
begin method A thread name = A
end
end

下面标注的更关键：

synchronized锁重入

出现异常，锁自动释放

同步不具有继承性

synchronized同步语句块

synchronized同步语句块的使用

package multiply.com.test;
public class Run {
    public static void main(String[] args) {
        ObjectService service = new ObjectService();
        ThreadA aThread = new ThreadA(service);
        ThreadB bThread = new ThreadB(service);
        aThread.setName("a");
        bThread.setName("b");
        aThread.start();
        bThread.start();
    }
}

package multiply.com.test;
public class ThreadA extends Thread {
    private ObjectService service;

    public ThreadA(ObjectService service) {
        this.service = service;
    }
    @Override
    public void run() {
        super.run();
        service.serviceMethod();
    }
}

package multiply.com.test;
public class ThreadB extends Thread {
    private ObjectService service;

    public ThreadB(ObjectService service) {
        this.service = service;
    }
    @Override
    public void run() {
        super.run();
        service.serviceMethod();
    }
}

package multiply.com.test;
public class ObjectService {
	private String getData1;
	private String getData2;
	public void serviceMethod() {
		try {       
			System.out.println("begin task");
			Thread.sleep(2000);
			String privateGetData1 = "长时间处理任务后返回值1 threadName="+Thread.currentThread().getName();
			String privateGetData2 = "长时间处理任务后返回值2 threadName="+Thread.currentThread().getName();
			synchronized(this)
			{
				getData1 = privateGetData1;
				getData2 = privateGetData2;
			}
			System.out.println(getData1);
			System.out.println(getData2);
			System.out.println("end task");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

begin task
begin task
长时间处理任务后返回值1 threadName=b
长时间处理任务后返回值2 threadName=b
end task
长时间处理任务后返回值1 threadName=a
长时间处理任务后返回值2 threadName=a
end task

将任意对象作为对象检测器

package multiply.com.test;
public class Run {
    public static void main(String[] args) {
        Service service = new Service();
        ThreadA aThread = new ThreadA(service);
        ThreadB bThread = new ThreadB(service);
        aThread.setName("A");
        bThread.setName("B");
        aThread.start();
        bThread.start();
    }
}

package multiply.com.test;
public class ThreadA extends Thread {
    private Service service;

    public ThreadA(Service service) {
        this.service = service;
    }
    @Override
    public void run() {
        super.run();
        service.a();
    }
}

package multiply.com.test;
public class ThreadB extends Thread {
    private Service service;

    public ThreadB(Service service) {
        this.service = service;
    }
    @Override
    public void run() {
        super.run();
        service.b();
    }
}

package multiply.com.test;
public class Service {
    private String anyString = new String();
    public void a() {
        try {
            synchronized (anyString) {
                System.out.println("a begin");
                Thread.sleep(3000);
                System.out.println("a   end");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    synchronized public void b() {
        System.out.println("b begin");
        System.out.println("b   end");
    }
}

细化验证三个结论

package multiply.com.test;
public class Run {
    public static void main(String[] args) {
        Service service = new Service();
        MyObject object = new MyObject();
        ThreadA aThread = new ThreadA(object, service);
        ThreadB bThread = new ThreadB(object);
        aThread.setName("a");
        bThread.setName("b");
        aThread.start();
        bThread.start();
    }
}

package multiply.com.test;
public class ThreadA extends Thread {
    private MyObject object;
    private Service service;

    public ThreadA(MyObject object, Service service) {
        this.object = object;
        this.service = service;
    }
    @Override
    public void run() {
        super.run();
        service.testMethod1(object);
    }
}

package multiply.com.test;
public class ThreadB extends Thread {
    private MyObject object;

    public ThreadB(MyObject object) {
        this.object = object;
    }
    @Override
    public void run() {
        super.run();
        object.speedPrintString();
    }
}

package multiply.com.test;
public class Service {
    public void testMethod1(MyObject object) {
        synchronized (object) {
            try {
                System.out.println("test method 1 __getLock time = " + System.currentTimeMillis() + " Run thread name = " + Thread.currentThread().getName());
                Thread.sleep(5000);
                System.out.println("test method 1 releaseLock time = " + System.currentTimeMillis() + " Run thread name = " + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

package multiply.com.test;
public class MyObject {
    public void speedPrintString() {
        synchronized (this) {
            System.out.println("speedPrintString __getLock time = " + System.currentTimeMillis() + " Run thread name " + Thread.currentThread().getName());
            System.out.println("------------------------------------------------");
            System.out.println("speedPrintString releaseLock time = " + System.currentTimeMillis() + " Run thread name " + Thread.currentThread().getName());
        }

    }
}

speedPrintString __getLock time = 1634822778915 Run thread name b
− − − − − − − − − − − − − − − − − − − − − − − − − − − − − − ------------------------------ −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
speedPrintString releaseLock time = 1634822778915 Run thread name b
test method 1 __getLock time = 1634822778915 Run thread name = a
test method 1 releaseLock time = 1634822783917 Run thread name = a

Java多线程

Java相关栏目本月热门文章