Java并发实战

最新推荐文章于 2024-05-10 22:51:57 发布
最新推荐文章于 2024-05-10 22:51:57 发布
阅读量243 收藏
点赞数
分类专栏： 实习前的准备
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hyo555/article/details/80834617
版权

Java并发实战

使用线程的三种方法

有三种使用线程的方法：

  • 实现 Runnable 接口；
  • 实现 Callable 接口；
  • 继承 Thread 类。

实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。

实现 Runnable 接口

需要实现 run() 方法。

通过 Thread 调用 start() 方法来启动线程。

public class MyRunnable implements Runnable {
    public void run() {
        // ...
    }
}
public static void main(String[] args) {
    MyRunnable instance = new MyRunnable();
    Thread thread = new Thread(instance);
    thread.start();
}

实现 Callable 接口

与 Runnable 相比，Callable 可以有返回值，返回值通过 FutureTask 进行封装。

public class MyCallable implements Callable<Integer> {
    public Integer call() {
        return 123;
    }
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
    MyCallable mc = new MyCallable();
    FutureTask<Integer> ft = new FutureTask<>(mc);
    Thread thread = new Thread(ft);
    thread.start();
    System.out.println(ft.get());
}

继承 Thread 类

同样也是需要实现 run() 方法，因为 Thread 类也实现了 Runable 接口。

public class MyThread extends Thread {
    public void run() {
        // ...
    }
}
public static void main(String[] args) {
    MyThread mt = new MyThread();
    mt.start();
}

 

多线程并行和并发的区别

* 并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
* 并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，
由于时间间隔较短，使人感觉两个任务都在运行。

 

Java程序运行原理和JVM的启动是多线程的吗

A:Java程序运行原理
	* Java命令会启动java虚拟机，启动JVM，
	* 等于启动了一个应用程序，也就是启动了一个进程。
	* 该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。
B:JVM的启动是多线程的吗
	* JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。

 

互斥同步

Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。

* 1.什么情况下需要同步
	* 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
	* 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.
* 2.同步代码块
	* 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
	* 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的

 

synchronized

1. 同步一个代码块

public void func() {
    synchronized (this) {
        // ...
    }
}

它只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。

对于以下代码，使用 ExecutorService 执行了两个线程，由于调用的是同一个对象的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语句块时，另一个线程就必须等待。

public class SynchronizedExample {

    public void func1() {
        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        }
    }
}
public static void main(String[] args) {
    SynchronizedExample e1 = new SynchronizedExample();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> e1.func1());
    executorService.execute(() -> e1.func1());
}
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

对于以下代码，两个线程调用了不同对象的同步代码块，因此这两个线程就不需要同步。从输出结果可以看出，两个线程交叉执行。

public static void main(String[] args) {
    SynchronizedExample e1 = new SynchronizedExample();
    SynchronizedExample e2 = new SynchronizedExample();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> e1.func1());
    executorService.execute(() -> e2.func1());
}
0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9

2. 同步一个方法

public synchronized void func () {
    // ...
}

它和同步代码块一样，作用于同一个对象。

3. 同步一个类

public void func() {
    synchronized (SynchronizedExample.class) {
        // ...
    }
}

作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也会进行同步。

public class SynchronizedExample {

    public void func2() {
        synchronized (SynchronizedExample.class) {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        }
    }
}
public static void main(String[] args) {
    SynchronizedExample e1 = new SynchronizedExample();
    SynchronizedExample e2 = new SynchronizedExample();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> e1.func2());
    executorService.execute(() -> e2.func2());
}
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

4. 同步一个静态方法

public synchronized static void fun() {
    // ...
}

作用于整个类。

 

 

多线程安全问题

* 多线程并发操作同一数据时, 就有可能出现线程安全问题
* 使用同步技术可以解决这种问题, 把操作数据的代码进行同步, 不要多个线程一起操作
* 
 需求:铁路售票,一共100张,通过四个窗口卖完.

注意体会加锁时的各种方法

public class m {
 
	/**
	 * 需求:铁路售票,一共100张,通过四个窗口卖完.
	 * 通过四个线程出售
	 */
	public static void main(String[] args) {
		new Ticket().start();
		new Ticket().start();
		new Ticket().start();
		new Ticket().start();
	}
 
}
 
class Ticket extends Thread {
	private static int ticket = 100;//加static,所有对象共享这100张票
	//private Object obj = new Object();//相当于成员变量,前加static才能做锁对象	
	//private static Object obj = new Object();	//如果用引用数据类型成员变量当作锁对象,必须是静态的
	public void run() {
		while(true) {
			synchronized(Ticket.class) {//加this不行,每new一次都是一个新的对象新的锁
				if(ticket <= 0) {
					break;
				}
				
				try {
					Thread.sleep(10);	//线程1睡,线程2睡,线程3睡,线程4睡
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
				System.out.println(getName() + "...这是第" + ticket-- + "号票");
			}
		}
	}
}

 

public class n {
 
	/**
	 * @param args
	 * 火车站卖票的例子用实现Runnable接口
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyTicket mt = new MyTicket();
		new Thread(mt).start();
		new Thread(mt).start();
		new Thread(mt).start();
		new Thread(mt).start();
		
		
		/*Thread t1 = new Thread(mt);	//多次启动一个线程是非法的
		t1.start();
		t1.start();
		t1.start();
		t1.start();*/
	}
 
}
 
class MyTicket implements Runnable {
	private int tickets = 100;//不用static,他不用创建多个对象,只需当做参数传递
	@Override
	public void run() {
		while(true) {
			//synchronized(Ticket.class),同理,锁对象也可以用this
			synchronized(this) {
				if(tickets <= 0) {
					break;
				}
				try {
					Thread.sleep(10);	//线程1睡,线程2睡,线程3睡,线程4睡
				} catch (InterruptedException e) {
					
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "...这是第" + tickets-- + "号票");
			}
		}
	}
}

 

public class o {
 
	/**
	 * @param args
	 * 需求:铁路售票,一共100张,通过四个窗口卖完.
	 */
	public static void main(String[] args) {
		TicketsSeller t1 = new TicketsSeller();
		TicketsSeller t2 = new TicketsSeller();
		TicketsSeller t3 = new TicketsSeller();
		TicketsSeller t4 = new TicketsSeller();
		
		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");
		t4.setName("窗口4");
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
 
}
 
class TicketsSeller extends Thread {
	private static int tickets = 100;
	static Object obj = new Object();
	public TicketsSeller() {
		super();
		
	}
	public TicketsSeller(String name) {
		super(name);
	}
	public void run() {
		while(true) {
			synchronized(obj) {
				if(tickets <= 0) 
					break;
				try {
					Thread.sleep(10);//线程1睡,线程2睡,线程3睡,线程4睡
				} catch (InterruptedException e) {
					
					e.printStackTrace();
				}
				System.out.println(getName() + "...这是第" + tickets-- + "号票");
			}
		}
	}
}

 

多线程死锁

 多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁
	* 尽量不要嵌套使用
public class p {
 
	/**
	 * @param args
	 */
	private static String s1 = "筷子左";
	private static String s2 = "筷子右";
 
	public static void main(String[] args) {
		new Thread() {
			public void run() {
				while(true) {
					synchronized(s1) {
						System.out.println(getName() + "...获取" + s1 + "等待" + s2);
						synchronized(s2) {
							System.out.println(getName() + "...拿到" + s2 + "开吃");
						}
					}
				}
			}
		}.start();
		
		new Thread() {
			public void run() {
				while(true) {
					synchronized(s2) {
						System.out.println(getName() + "...获取" + s2 + "等待" + s1);
						synchronized(s1) {
							System.out.println(getName() + "...拿到" + s1 + "开吃");
						}
					}
				}
			}
		}.start();
	}
}

线程之间的协作

当多个线程可以一起工作去解决某个问题时，如果某些部分必须在其它部分之前完成，那么就需要对线程进行协调。

join()

在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待，直到目标线程结束。

对于以下代码，虽然 b 线程先启动，但是因为在 b 线程中调用了 a 线程的 join() 方法，b 线程会等待 a 线程结束才继续执行，因此最后能够保证 a 线程的输出先于 b 线程的输出。

public class JoinExample {

    private class A extends Thread {
        @Override
        public void run() {
            System.out.println("A");
        }
    }

    private class B extends Thread {

        private A a;

        B(A a) {
            this.a = a;
        }

        @Override
        public void run() {
            try {
                a.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("B");
        }
    }

    public void test() {
        A a = new A();
        B b = new B(a);
        b.start();
        a.start();
    }
}
public static void main(String[] args) {
    JoinExample example = new JoinExample();
    example.test();
}
A
B

wait() notify() notifyAll()

调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。

它们都属于 Object 的一部分，而不属于 Thread。

只能用在同步方法或者同步控制块中使用，否则会在运行时抛出 IllegalMonitorStateExeception。

使用 wait() 挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁。

public class WaitNotifyExample {
    public synchronized void before() {
        System.out.println("before");
        notifyAll();
    }

    public synchronized void after() {
        try {
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("after");
    }
}
public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    WaitNotifyExample example = new WaitNotifyExample();
    executorService.execute(() -> example.after());
    executorService.execute(() -> example.before());
}
before
after

wait() 和 sleep() 的区别

  • wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法；
  • wait() 会释放锁，sleep() 不会。

await() signal() signalAll()

java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。

使用 Lock 来获取一个 Condition 对象。

public class AwaitSignalExample {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void before() {
        lock.lock();
        try {
            System.out.println("before");
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void after() {
        lock.lock();
        try {
            condition.await();
            System.out.println("after");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    AwaitSignalExample example = new AwaitSignalExample();
    executorService.execute(() -> example.after());
    executorService.execute(() -> example.before());
}
before
after
Hyo_yew
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java并发实战
09-29
《Java并发编程实战》这本书是Java并发编程领域的一本经典之作，它深入浅出地讲解了如何在Java环境中有效地管理并发。以下是对该书主要内容的详细解析： 1. **并发基础**：书中首先介绍了并发的基本概念，包括线程...
Java并发编程实践
BXA
05-30 2183
并发编程是指通过设计和实现多线程程序来利用计算机资源和提高程序执行效率的编程方法。它的主要特点是多线程之间的竞争和协作关系。线程安全性是指并发编程中，在多个线程访问共享数据时，对数据的访问不会产生意料之外的后果。实现线程安全性需要从数据的状态变化过程进行分析，并采用相应的线程安全策略。
Java并发实战-高阶工具
weixin_45278397的博客
10-12 92
在日常开发中，我们面临着越来越多的并发计算需求。应用程序需要能够处理大规模的并发请求、保证高性能和可靠性，并且能够适应不断增长的用户量。本文总结了一些好用高级的并发工具，为并发问题提供更多解决方案。
【Java面试】并发编程实战（线程控制操作详解）_java并发编程实战(1)
最新发布
2401_84164576的博客
05-10 793
①继承 Thread 类，重写 run 方法。@Override②实现 Runnable 接口，实现 run 方法。推荐使用，避免了单继承的局限性。@Override通过匿名内部类方式，我们可以实现同时定义和启动线程的简洁写法。}).start();
Java并发编程实战(一)
qq_40662424的博客
03-27 1247
xxx系列文章 xxxx系列(1)― xxxx系列(2)― xxxxx系列(3)― 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录xxx系列文章前言一、一级标题1二、一级标题21.二级标题总结 前言 晚上刷视频刷到河北王校长的bug排除视频，校长深厚的基本功令我汗颜，需要好好学习一下多线程的相关知识了，由此开了这个系列，以极客专栏的学习为主，记下笔记，辅以processon画流程图，尽可能提高自己的并发编程水平 参考链接： 一、一级标题1 　　Java 里 sync
java实战分享
Gefangenes的博客
06-28 428
这篇文章，笔者总结了四种非常强大且隐秘的缓存。1、HashMap/ConcurrentHashMap 经常用于配置缓存，对于 HashMap 来讲，HashMap + 读写锁 + 定时任务更新是常用的模式。而 ConcurrentHashMap 广泛存在于各种中间件，线程安全且灵活易用。2、LinkedHashMap 经常被用于创建最近最少使用缓存 LruCache。推荐学习 Mybatis 二级缓存的设计，它使用责任链装饰器。
java入门实战
huolonzhang的博客
04-23 1172
Java中的数据类型包括基本数据类型和引用数据类型两种。基本数据类型有byte、short、int、long、float、double、boolean、char八种，引用数据类型有String、数组、类等。本文介绍了Java开发入门的基本步骤和语法，包括环境搭建、基本语法、数据类型、变量声明和赋值、运算符等。Java有许多关键字，如public、class、void等，这些关键字在Java中有特定的含义，不能用来做变量名或方法名等。Java中的运算符包括算术运算符、关系运算符、逻辑运算符、位运算符等。
java并发实战教程
03-29
超全的java并发编程实战文档，有源码有实例，是java初学者，想提高自己编程水平的宝典。
java并发实战中文文档
12-11
《Java并发实战》是一本深度剖析Java并发编程的权威指南，旨在帮助开发者高效地理解和解决多线程环境下的编程挑战。文档清晰明了，配备有详细的目录，使得学习过程更为顺畅，避免了在查找信息上浪费时间。标签“Java...
Java并发变成实战
09-14
java 并 发 编 程 实 战 和 java 并 发 编 程 实 战 手 册, p d f 格 式 ,欢 迎 有 愿 学 习并 发 的 同 仁下 载
（PDF带目录）《Java 并发编程实战》，java并发实战，并发
10-19
这就是最正宗的《Java 并发编程实战》带目录 用福昕阅读器打开查看特别的清晰
szdgsdgsgsdg
02-24
szdgsdgsgsdg
《java 并发编程实战高清PDF版》
03-14
深入讲解java并发编程技术，多线程、锁以及java内存模型等
java开发编程实战 最新版【高清完整版PDF，豆瓣9分神书】
10-13
java并发编程实战 pdf 高清完整版 本书深入浅出地介绍了Java线程和并发，是一本完美的Java并发参考手册。书中从并发性和线程安全性的基本概念出发，介绍了如何使用类库提供的基本并发构建块，用于避免并发危险、构造线程安全的类及验证线程安全的规则，如何将小的线程安全类组合成更大的线程安全类，如何利用线程来提高并发应用程序的吞吐量，如何识别可并行执行的任务，如何提高单线程子系统的响应性，如何确保并发程序执行预期任务，如何提高并发代码的性能和可伸缩性等内容，最后介绍了一些高级主题，如显式锁、原子变量、非阻塞算法以及如何开发自定义的同步工具类。 本书适合Java程序开发人员阅读。
java并发变成实战
04-25
java并发编程实战中文高清版本电子书，无水印，pdf版本，详细介绍了并发如何处理，是开发高tps编程的必备书籍
Java 并发编程实战
weixin_43304273的博客
05-25 55
进程与线程；线程安全
Java异步编程实战：基于JDK中的Future实现异步编程
技术原始积累
01-01 1951
本节内容摘自《Java异步编程实战》中的一小节。一、前言本节主要讲解如何使用JDK中的Future实现异步编程，这包含如何使用FutureTask实现异步编程以及其内部实现原理以及Fut...
java并发编程实战
weixin_47843332的博客
06-27 330
Volatile变量 valatile是java提供的一种稍弱的同步机制，用来确保将变量的更新操作通知到其他线程。当把变量声明为volatile后，编译器与运行时都会注意到这个变量是共享的，因此不会将变量上的操作与其他内存操作一起重排序【1】。volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值。 【1】：当线程A首先写入一个volatile变量并且线程B随后读取该变量时，在写入volatile变量之前对A可见的所有变量的值，在B读取
Java并发编程实战
07-27
Java并发编程实战是一本非常经典的书籍，由Brian Goetz等人撰写。该书主要介绍了Java中的并发编程技术和最佳实践，帮助开发者更好地理解并发编程的概念和挑战，并提供了解决方案和示例代码。 这本书涵盖了多线程、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值