本文详细介绍了Java中的多线程概念，包括其优点和缺点，如提高程序效率、内存占用和CPU负担。深入探讨了并行与并发的区别，以及线程并发中的同步锁机制，如synchronized和Lock接口的ReentrantLock。还讨论了线程死锁问题及其预防，并展示了线程通信的实例，最后提到了Callable接口创建线程的新方式。
目录
多线程
多线程是指一个应用程序内部可以同时执行多个任务,一个程序可以创建多个并行的执行单元即(多个线程)执行多个任务
什么时候需要使用多线程:
当一个程序需要同时执行多个任务的时候;
程序需要实现多个等待的任务的时候,例如文件读写操作,网络操作,用户输入操作,搜索等操作
多线程的优点
可以更加高效的执行程序,提高程序的处理能力与程序的响应速度
可以更加高效的使用CPU,压榨硬件的价值
可以改善程序的结构,将复杂的任务分配在不同的线程上独立完成
多线程的缺点
线程的运行需要占用内存的空间,过多的线程占用内存会加大内存的负担
线程的处理需要CPU的时间跟踪,过多的线程并行也会增加CPU处理的负担
多个线程对同个共享资源进行访问的问题
并行与并发
并行:在同个时间段,多个事情执行多个任务(例如多个人在同个时间段,做不同的事,彼此间互不干扰)
并发:在同个时间段,多个事情依次执行同个操作(例如卖票,抢购,秒杀看似同时进行,实际是一个一个执行)
线程并发
多线程同步 ● 多个线程同时读写同一份共享资源时，可能会引起冲突。所以引入线程“同步”机制，即各线程间要有先来后到； 同步就是排队+锁： ● 几个线程之间要排队，一个个对共享资源进行操作，而不是同时进行操作； ● 为了保证数据在方法中被访问时的正确性，在访问时加入锁机制
同步锁
若需要实现在同一个时间点只有一个线程能访问共享资源,可以对资源施加一把同步锁,只有获得该锁的线程才能访问该资源
synchronized(同步锁)关键字,可以同步方法或代码块。 synchronized (同步锁）{ // 需要被同步的代码； } synchronized在方法中声明 public synchronized void show (String name){ // 需要被同步的代码； }
synchronized修饰非静态成员方法时锁对象调用的this
synchronized修饰静态的成员方法时锁对象调用的是class对象
同步锁 同步锁可以是任何对象,必须唯一,保证多个线程获得是同一个对象(用 来充当锁标记). 同步执行过程 1.第一个线程访问，锁定同步对象，执行其中代码. 2.第二个线程访问，发现同步对象被锁定，无法访问. 3.第一个线程访问完毕，解锁同步对象. 4.第二个线程访问，发现同步对象没有锁，然后锁定并访问.
public class TicketDemo extends Thread {
//模拟买票的线程
static int num=10;
static Object object="标识对象";
@Override
public void run() {
while(true) {
synchronized (object) {//加入同步锁对代码块进行修饰,只有一个线程可以进入该代码块
//object是一个唯一的对象作为同步锁,对象可以是任意类型的,此对象记录有没有线程进入该代码块
if (num > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + num);
num--;
} else {
break;
}
}
}
}
}
//测试代码
TicketDemo2 ticketDemo2=new TicketDemo2();
Thread thread=new Thread(ticketDemo2,"窗口1");
Thread thread1=new Thread(ticketDemo2,"窗口2");
thread.start();
thread1.start();Lock锁
Lock接口与ReentrantLock类位于java.util.concurrent.locks包下
从JDK 5.0开始，Java提供了更强大的线程同步机制-通过显式定义同步锁对象来实现同步,同步锁使用Lock对象充当
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义,功能也相同,在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁
public class TicketDemo2 implements Runnable {
int num=10;
Lock lock=new ReentrantLock();
@Override
public void run() {
while(true) {
try {
lock.lock();//lock()方法手动对指定代码块进行添加锁
if (num > 0) {
System.out.println(Thread.currentThread().getName() + ":" + num);
num--;
} else {
break;
}
}finally {
lock.unlock();//手动对代码块进行释放锁,由于锁的添加与释放都是手动的,代码块中如果出现了异常则无法释放锁
//故一般与try/finally关键字一起使用,保证锁的是释放
}
}
}
}ReentrantLock与synchronized的区别:
ReentrantLock
ReentrantLock是一个类,其底层是由java代码实现的
ReentrantLock只能对代码块添加锁
ReentrantLock需要手动的添加与释放锁,代码块中出现异常会导致无法释放锁,故需要与try/finally搭配
synchronized
synchronized是一个关键字,是依靠底层编译过后的指令进行控制的
synchronized可以修饰方法与代码块
synchronized是隐式锁,代码块或者方法调用完之后,或者出现异常的情况会自动的释放锁,
死锁
死锁是一种多线程下进入的状态,不同线程抢占了对方所需要的的资源不肯放弃,都在等待对方释放所需要的资源,导致两个线程都进入了阻塞状态都不会在继续运行下去
死锁中的线程会进入阻塞状态,程序不会报错也不会出现异常,不会出现提示,而是一直在阻塞状态下
为了避免死锁状态的出现,在程序设计时应该考虑清楚锁的顺序,而且尽量避免锁的嵌套
//极端情况下的死锁案例
public class DieLockThread extends Thread {
//死锁测试线程
static Object object1=new Object();
static Object object2=new Object();
boolean flag;
public DieLockThread(boolean flag) {
this.flag=flag;
}
@Override
public void run() {
if (flag){
synchronized (object1){
System.out.println("if obj1");
synchronized (object2){
System.out.println("if obj2");
}
}
}else{
synchronized (object2){
System.out.println("else obj2");
synchronized (object1){
System.out.println("else obj1");
}
}
}
}
}线程通信
指多个线程相互牵制,相互调度的过程,即线程间的相互作用
线程通讯中涉及的三个方法:
wait一旦执行此方法，当前线程就进入阻塞状态，并释放同步锁。
notify一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。 notifyAll一旦执行此方法，就会唤醒所有被wait的线程。 注意： wait（），notify（），notifyAll（）三个方法必须使用在同步代码块或同步方法中。
案例:
生产者与消费者的模型
生产者(Productor)将产品放在柜台(Counter)，而消费者(Customer)从柜台处取走产品，生产者一次只能生产固定数量的产品(比如:1）， 这时柜台中不能再放产品,此时生产者应停止生产等待消费者拿走产品,此时生产者唤醒消费者来取走产品,消费者拿走产品后,唤醒生产者,消费者开始等待
//柜台类
public class Counter {
/*
柜台类
实现生产者消费者模型
*/
int num=0;
public synchronized void add(){
if (num==0){
num=1;
System.out.println("新增商品");
this.notify();
}else{
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void sub(){
if (num>0){
num=0;
System.out.println("拿走商品");
this.notify();
}else{
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//生产者线程
public class Producter extends Thread {
private Counter counter;
public Producter(Counter counter) {
this.counter = counter;
}
@Override
public void run() {
while(true){
counter.add();
}
}
}
//消费者线程
public class Customer extends Thread {
private Counter counter;
public Customer(Counter counter) {
this.counter = counter;
}
@Override
public void run() {
while(true){
counter.sub();
}
}
}
//测试程序
public class Test {
public static void main(String[] args) {
Counter counter=new Counter();
new Customer(counter).start();
new Producter(counter).start();
}
}创建线程的新方式--Callable接口
Callable接口的功能与Runnable接口功能类似,但是Callable接口是一个泛型接口,实现时需要定义泛型
Callable接口与Runnable接口的区别:
1.Callable接口需要重写call()方法,该方法有返回值并且可以抛出异常
2.借助FutureTask类来获取返回值,返回值是指定的泛型值
3.在使用Thread类创建线程的时候不能直接传入Callable接口的实现类,而是需要使用FutureTask类来接收Callable实现类的对象,然后再用Thread类接收FutureTask类的对象创建线程
//Callable实现类
public class Sum implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int j=0;
for (int i = 0; i <5 ; i++) {
j+=i;
}
return j;
}
}
//测试代码
public class Test {
public static void main(String[] args) {
Sum sum=new Sum();
/*
由于不是Runnable接口故无法直接利用Thread类创建线程,在Callable接口中需要使用FutureTask类来接收Callable接口的实现类
*/
FutureTask futureTask=new FutureTask(sum);
new Thread(futureTask).start();//FutureTask类是继承自Runnable接口的实现类
try {//解决抛出的异常
System.out.println(futureTask.get());//FutureTask类中的get方法可以拿到返回值
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
扫一扫
1276
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
