多线程的同步依靠的是对象锁机制,synchronized关键字的背后就是利用了封锁来实现对共享资源的互斥访问。
下面以一个简单的实例来进行对比分析。实例要完成的工作非常简单,就是创建10个线程,每个线程都打印从0到99这100个数字,我们希望线程之间不会出现交叉乱序打印,而是顺序地打印。
先来看第一段代码,这里我们在run()方法中加入了synchronized关键字,希望能对run方法进行互斥访问,但结果并不如我们希望那样,这是因为这里synchronized锁住的是this对象,即当前运行线程对象本身。代码中创建了10个线程,而每个线程都持有this对象的对象锁,这不能实现线程的同步。
引用
代码
- package com.vista;
-
-
class MyThread implements java.lang.Runnable
- {
-
private int threadId;
-
-
public MyThread(int id)
- {
-
this.threadId = id;
- }
-
@Override
-
public synchronized void run()
- {
-
for (int i = 0; i < 100; ++i)
- {
-
System.out.println("Thread ID: " + this.threadId + " : " + i);
- }
- }
- }
-
public class ThreadDemo
- {
-
-
public static void main(String[] args) throws InterruptedException
- {
-
for (int i = 0; i < 10; ++i)
- {
-
new Thread(new MyThread(i)).start();
-
Thread.sleep(1);
- }
- }
- }
package com.vista;
class MyThread implements java.lang.Runnable
{
private int threadId;
public MyThread(int id)
{
this.threadId = id;
}
@Override
public synchronized void run()
{
for (int i = 0; i < 100; ++i)
{
System.out.println("Thread ID: " + this.threadId + " : " + i);
}
}
}
public class ThreadDemo
{
public static void main(String[] args) throws InterruptedException
{
for (int i = 0; i < 10; ++i)
{
new Thread(new MyThread(i)).start();
Thread.sleep(1);
}
}
}
从上述代码段可以得知,要想实现线程的同步,则这些线程必须去竞争一个唯一的共享的对象锁。
基于这种思想,我们将第一段代码修改如下所示,在创建启动线程之前,先创建一个线程之间竞争使用的Object对象,然后将这个Object对象的引用传递给每一个线程对象的lock成员变量。这样一来,每个线程的lock成员都指向同一个Object对象。我们在run方法中,对lock对象使用 synchronzied块进行局部封锁,这样就可以让线程去竞争这个唯一的共享的对象锁,从而实现同步。
代码
- package com.vista;
-
-
class MyThread implements java.lang.Runnable
- {
-
private int threadId;
-
private Object lock;
-
public MyThread(int id, Object obj)
- {
-
this.threadId = id;
-
this.lock = obj;
- }
-
@Override
-
public void run()
- {
-
synchronized(lock)
- {
-
for (int i = 0; i < 100; ++i)
- {
-
System.out.println("Thread ID: " + this.threadId + " : " + i);
- }
- }
- }
- }
-
public class ThreadDemo
- {
-
-
public static void main(String[] args) throws InterruptedException
- {
-
Object obj = new Object();
-
for (int i = 0; i < 10; ++i)
- {
-
new Thread(new MyThread(i, obj)).start();
-
Thread.sleep(1);
- }
- }
- }
package com.vista;
class MyThread implements java.lang.Runnable
{
private int threadId;
private Object lock;
public MyThread(int id, Object obj)
{
this.threadId = id;
this.lock = obj;
}
@Override
public void run()
{
synchronized(lock)
{
for (int i = 0; i < 100; ++i)
{
System.out.println("Thread ID: " + this.threadId + " : " + i);
}
}
}
}
public class ThreadDemo
{
public static void main(String[] args) throws InterruptedException
{
Object obj = new Object();
for (int i = 0; i < 10; ++i)
{
new Thread(new MyThread(i, obj)).start();
Thread.sleep(1);
}
}
}
从第二段代码可知,同步的关键是多个线程对象竞争同一个共享资源即可,上面的代码中是通过外部创建共享资源,然后传递到线程中来实现。我们也可以利用类成员变量被所有类的实例所共享这一特性,因此可以将lock用静态成员对象来实现,代码如下所示:
代码
- package com.vista;
-
-
class MyThread implements java.lang.Runnable
- {
-
private int threadId;
-
private static Object lock = new Object();
-
public MyThread(int id)
- {
-
this.threadId = id;
- }
-
@Override
-
public void run()
- {
-
synchronized(lock)
- {
-
for (int i = 0; i < 100; ++i)
- {
-
System.out.println("Thread ID: " + this.threadId + " : " + i);
- }
- }
- }
- }
-
public class ThreadDemo
- {
-
-
public static void main(String[] args) throws InterruptedException
- {
-
for (int i = 0; i < 10; ++i)
- {
-
new Thread(new MyThread(i)).start();
-
Thread.sleep(1);
- }
- }
- }
- package com.vista;
class MyThread implements java.lang.Runnable
{
private int threadId;
private static Object lock = new Object();
public MyThread(int id)
{
this.threadId = id;
}
@Override
public void run()
{
synchronized(lock)
{
for (int i = 0; i < 100; ++i)
{
System.out.println("Thread ID: " + this.threadId + " : " + i);
}
}
}
}
public class ThreadDemo
{
public static void main(String[] args) throws InterruptedException
{
for (int i = 0; i < 10; ++i)
{
new Thread(new MyThread(i)).start();
Thread.sleep(1);
}
}
}
再来看第一段代码,实例方法中加入sychronized关键字封锁的是this对象本身,而在静态方法中加入sychronized关键字封锁的就是类本身。静态方法是所有类实例对象所共享的,因此线程对象在访问此静态方法时是互斥访问的,从而可以实现线程的同步,代码如下所示:
代码
package com.vista;
class MyThread implements java.lang.Runnable
{
private int threadId;
public MyThread(int id)
{
this.threadId = id;
}
@Override
public void run()
{
taskHandler(this.threadId);
}
private static synchronized void taskHandler(int threadId)
{
for (int i = 0; i < 100; ++i)
{
System.out.println("Thread ID: " + threadId + " : " + i);
}
}
}
public class ThreadDemo
{
public static void main(String[] args) throws InterruptedException
{
for (int i = 0; i < 10; ++i)
{
new Thread(new MyThread(i)).start();
Thread.sleep(1);
}
}
}
分享到:
相关推荐
java基于socket聊天室源代码.rar 注:供java socket编程的初学者学习使用,严禁用作作业抄袭和商业用途。若转载源代码,请注明原作者以及作者的博客地址。 项目名称:...单播,解决了多线程同步的问题。
首先,多线程是Java中的一个关键特性,它允许程序同时执行多个任务,提高系统的效率和响应性。Java提供了多种方式来创建和管理线程,如通过实现Runnable接口或继承Thread类。理解线程生命周期(新建、就绪、运行、...
理解线程同步(如synchronized关键字和Lock接口)以及并发工具类(如ExecutorService和Future)是处理并发问题的关键。 6. **输入/输出(I/O)**:Java的I/O流系统包括字符流和字节流,以及用于文件操作、网络通信...
6. **多线程**:学习如何创建和管理线程,理解同步机制,如synchronized关键字、wait()、notify()等。通过习题,可以实践多线程编程,解决并发问题。 7. **反射**:掌握Java反射机制,能够动态地获取类的信息并调用...
提供在线阅读方式个人自建博客,CSDN博客。转载须知转载请联系GitHub出处,让我们共同...1、Java并发体系-第一阶段-多线程基础知识2、Java并发体系-第二阶段-锁与同步-[1]3、Java并发体系-第二阶段-锁与同步-[2]4、Jav
1、供java socket编程的初学者学习使用,严禁用作作业抄袭和商业用途。若转载源代码,请注明原作者以及作者的博客地址。 2、TCPChatRoomServer(服务器端),TCPChatRoomClient...单播,解决了多线程同步的问题。
3. 多线程:介绍线程的创建和管理,线程同步机制,如synchronized关键字,wait和notify方法,以及线程池的使用。 4. 反射:讨论Java反射机制,它允许程序在运行时访问和修改类的行为,是框架开发中的重要技术。 5....
4. **多线程**:Java中的线程创建方式(Thread类和Runnable接口),线程同步机制(synchronized,volatile,Lock,Semaphore等),以及死锁、活锁、饥饿现象的解释和避免策略。 5. **异常处理**:理解Checked异常和...
3. **多线程** - **线程状态**:新建、运行、阻塞、等待、终止等五种状态。 - **同步机制**:synchronized关键字,wait()、notify()和notifyAll()方法,以及Lock接口。 - **并发工具类**:如CountDownLatch、...
6. **多线程**:如何创建和管理线程,以及同步和互斥的概念。 7. **泛型**:如何使用泛型来提高代码的类型安全性和重用性。 8. **接口与抽象类**:它们的区别和使用场景。 9. **设计模式**:可能包含一些常见设计...
chap 14:当JNI遇到多线程--java对象如何被C++中的多个线程访问?. 97 chap 15:JNI在多线程中的应用... 101 chap 16:JNI限制(多线程)... 105 chap 17:使用 Java Native Interface 的最佳实践... 106 1....
它可以跨多个SessionFactory实例共享数据,提高了多线程和分布式环境下的性能。二级缓存分为查询缓存和集合缓存,分别用于存储查询结果和关联对象。 **3. 一级缓存工作原理:** 一级缓存是内存中的临时存储区域,当...
Hotspot实现了Java内存模型(JMM),确保了多线程环境下的数据一致性。它定义了变量访问规则、线程交互规则以及内存可见性,确保了并发编程的正确性。 5. **类加载机制** Hotspot遵循双亲委托模型进行类加载,从...
5. 多线程编程:线程同步、线程池、并发工具类等。 6. 网络编程:Socket通信、HTTP请求等。 7. Java异常处理:自定义异常、异常链、try-catch-finally语句块等。 8. 开源系统和框架:Spring Boot、Spring Cloud、...