并发基础2（线程方法、synchronize关键字、voliate、lock）

浅水壁虎

已于 2022-02-14 16:43:22 修改

阅读量597

点赞数

分类专栏： Java基础文章标签： java

于 2019-11-07 16:31:50 首次发布

本文链接：https://blog.csdn.net/huyiju/article/details/97646152

版权

Java基础专栏收录该内容

24 篇文章 0 订阅

订阅专栏

0：线程的状态

1:多线程的方法

1.1：Join()方法

1.2：Sleep()方法、wait()、yield()方法同属于Thread方法，不会释放锁

1.3：interrupt() 中断方法

1.4： wait() 、notifyAll（）、 notify()方法（使用在锁方法内部）

2：synchronize关键字

2.1：说一下对synchronize关键字的理解

2.2：synchronize在用项目中用到了吗？

2.2.1：synchronize用法

2.2.2：项目中的使用（懒汉单例模式）

3：说说synchronize关键字和voliate关键字

0：线程的状态

线程的状态有5种：

1：新建（New）：使用new关键字创建尚未启动的线程。new Thread()；就是新建一个线程

2：运行(Ruanable)：Runable包含线程的运行和就绪两种状态，也就是此时的线程正在运行或者在等待cpu为其分配执行时间

3：无限等待（Waiting）：这个时候的线程不会被CPU分配执行时间，他们要等待被其他线程显示的唤醒。一下方法会导致线程无限等待

没有设置Timeout参数的Object.wait()方法

没有设置Timeout参数的Thread.join()方法

LockSuport.park()方法

4：超时等待（Timed Wating）:这种状态不会被cpu分配执行时间。不过无需等待被其他线程唤醒，在一定时间之后会被系统自动唤醒。以下方法会进入超市等待。

Thread.sleep()

设置Timeout参数的Object.wait()方法

设置Timeout参数的Thread.join()方法

5：阻塞（Blocked）：阻塞的与等待的意思是阻塞是在等待获取一个排他锁，这个事件将在其他的线程使用这个锁的时候发生

1:多线程的方法

1.1：Join()方法

定义：当前线程加入父线程，父线程挂起，t.join()方法只会使主线程进入等待池并等待t线程执行完毕后才会被唤醒

直到当前线程执行结束后才能执行父线程。由源码可知父线程进入 wait(等待时间)，如果设置了时间，父亲线程wait(时间结束之后再运行)

案例：

	public static void main(String[] args) throws InterruptedException {
			Thread thread=new Thread(new Runnable() {
				@Override
				public void run() {
					// TODO Auto-generated method stub
					for (int i = 0; i < 5; i++) {
						System.out.println("子线程名字："+Thread.currentThread().getName());
					}
				}
			});
			thread.start();
			thread.join();
			System.out.println("父线程名字："+Thread.currentThread().getName());
	}

输出结果分析：当前子线程执行结束才能执行父线程，但是当时同步运行的其他线程不会阻塞，会继续运行。

当jion() 方法由参数的时候，会在传递的时间结束之后唤醒主线程。

1.2：sleep()方法、yield()方法同属于Thread方法，不会释放锁

sleep定义：(不会释放锁，释放cpu). 指定当前线程睡眠时间，在睡眠时间内依然保留锁，不会释放锁，cpu会监事当前线程的睡眠时间，时间到了之后CPU会立刻执行当前线程。也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据

yield定义：(不会释放锁，线程让步,抢占cpu). 自己的线程有运行状态变成就绪状态，自己和其他的线程一起竞争，线程优先级高的先执行，但是不绝对，只是大概率让线程优先级高的执行，包括自己的线程。

wait定义：(wait会释放锁，释放cpu). 线程处于等待状态，不能主动再次执行，需要别的线程调用同对象的notifyAll或者notify方法唤醒才能执行。属于object方法，在synchronize块中使用

sleep案例：

public static void main(String[] args) throws InterruptedException {
		long start=System.currentTimeMillis();
			Thread thread=new Thread(new Runnable() {
				@Override
				public void run() {
					// TODO Auto-generated method stub
					for (int i = 0; i < 5; i++) {
						System.out.println("子线程名字："+Thread.currentThread().getName());
					}
					try {//线程挂起1000毫秒
						Thread.currentThread().sleep(1000);;
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			},"自定义名字");
			//thread.notify();
			thread.start();
			Thread.currentThread().sleep(1000);
			thread.join();
			System.out.println("父线程名字："+Thread.currentThread().getName());
			System.out.println("耗时："+(System.currentTimeMillis()-start));
	}

yield案例

package com.thit.thread1;

public class YieldTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
    Thread a=new Thread(new Runnable() {
		
		@Override
		public void run() {
			// TODO Auto-generated method stub
			for (int i = 0; i <10; i++) {
				System.out.println("a线程优先级低："+i);
				//每次出让线程，但是a由于优先级低   大概率抢不到下次执行
				Thread.yield();
			}
		}
	});
    
	 Thread b=new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for (int i = 0; i <10; i++) {
					System.out.println("b线程优先级高："+i);
					Thread.yield();//出让当前资源，由于线程优先级高，大概率会下次执行
				}
			}
		});
	 
	 a.setPriority(Thread.MIN_PRIORITY);//a线程优先级低
	 b.setPriority(Thread.MAX_PRIORITY);//b线程优先级高
    
	 b.start();
	 a.start();
	
    
	}
	

	
}

执行结果不是每次都能按照预测的结果，因为线程释放之后重新开始运行随机性很大，并且线程优先级映射到windows内核也很不确定。

1.3：interrupt() 中断方法

定义：该方法只是改变中断状态而已，它不会中断一个正在运行的线程。
这一方法实际完成的是，给受阻塞的线程发出一个中断信号，这样受阻线程就得以退出阻塞的状态。唤醒正在睡眠的程序，调用interrupt()方法，会使得sleep()方法抛出InterruptedException异常，当sleep()方法抛出异常就中断了sleep的方法，从而让程序继续运行下去

结果如下：

1.4： wait() 、notifyAll（）、 notify()方法（使用在锁方法内部）

wait、notify和notifyAll方法是Object类的final native方法。所以这些方法不能被子类重写，Object类是所有类的超类，因此在程序中可以通过this或者super来调用this.wait(), super.wait()

wait方法定义：会释放锁，导致线程进入阻塞状态，会等待被其他线程使用notify方法唤醒，该方法只能在同步方法中执行，

notify方法定义：只能使用在同步方法和同步代码中，此方法只能随机选择一个在该对象的上调用wait方法的线程

notifyAll方法定义: 唤醒所有的wait对象

注意

1：Object.wait()和Object.notify()和Object.notifyall()必须写在synchronized方法内部或者synchronized块内部:原因是防止被提前唤醒，永远等待

2：注意那个对象等待就通知那个对象使用notify方法，不要让A对象等待，结果却去通知B对象，要操作同一个对象

package com.thit.thread2;

/**
 * @author :huyiju
 * @date :7/28/21 9:23 PM
 */
public class NotifyT1 {
    static boolean flag=true;
    static Object lock=new Object();
    public static void main(String[] args) {
        //等待线程启动
        Wait1 wait1=new Wait1();
        wait1.start();

        Notify1 notify1=new Notify1();
        notify1.start();

    }

    //必须存在到加锁的方法中
    public static class Wait1 extends Thread{
        @Override
        public void run() {
            synchronized (lock){
                while (flag){
                    System.out.println("如果状态为true则等待！先处理一些事情");
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("等待线程被唤醒");
                }
            }
        }
    }

    //必须存在到加锁的方法中
    public static class Notify1 extends Thread{
        @Override
        public void run() {
            synchronized (lock){
                System.out.println("唤醒线程处理一些事情，然后唤醒等待线程！");
                flag=false;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("---开始唤醒！---");

                lock.notifyAll();
            }
        }
    }
}

总结

此处有错误：join的底层方法是object的wait方法，所以会释放锁，释放cpu。

2：synchronize关键字

2.1：说一下对synchronize关键字的理解

synchronize关键字解决了多线程的资源同步性，该关键字保证了在多线程的条件下，同时是有一个线程能够获取到资源。

在jdk的早起版本中，这个关键字是重量级锁，这个关键字在编译之后，在同步块的前后会形成monitorenter和monitorexit（监视器进入和退出，通过获取对象锁计数器加一减一来实现锁机制）两个节码指令，其他线程在竞争的时候会挂起，效率低下，但是随着jdk的发展，通过对synchronize底层的发展，不必每次线程都挂起。来大大提升了效率

比如采用偏向锁、轻量级锁、锁粗化、锁自旋、锁自旋、锁消除等手段来提升效率。

2.2：synchronize在用项目中用到了吗？

2.2.1：synchronize用法

1：用来修饰静态方法（给类加了锁，无论new多少个对象，都会产生竞争，线程1new的对象获取普通加锁方法和线程2获取类的静态加锁方法不会产生竞争）

2：用来修饰静态代码块（也是给类加了锁，

synchronize(this)锁定当前类的对象和synchronize修饰普通方法效果相同（针对相同的对象发生阻塞）

synchronize(类名.class)锁定当前类和synchronize修饰静态方法效果相同（所有的对象都会发生阻塞）

synchronize(object) 锁定指定的对象，抢占资源

）

3：用来修饰普通方法（锁给了对象，只用new的同一对象才有竞争）

2.2.2：项目中的使用（懒汉单例模式）

代码块如下:双重锁效验线程安全

package com.thit.connpool;

public class LazySimple {
	//voliate修饰，禁止指令重排
	private static volatile LazySimple lazySimple;
	//私有构造防止new创建对象
	private LazySimple() {
		
	}
	//静态方法外部得到实例
	public static LazySimple getDanli() {
		//首先判断是否为空
		if (lazySimple==null) {
			synchronized (LazySimple.class) {
				//再次判断是否为空
				if(lazySimple==null) {
					//new 对象非原子性操作
					//1：分配内存空间
					//2：初始化值(构造器)
					//3：将对象指向内存地址
					lazySimple=new LazySimple();
				}
			}
		}
		return lazySimple;
	}
}

代码分析：

1：其中 volatile修饰lazySimple;是为了防止指令重排,其中lazySimple=new LazySimple();这段代码不是原子性操作，实际分为3步

//1：分配内存空间
                   //2：初始化值
                   //3：将引用指向内存地址
                   lazySimple=new LazySimple();

由于jvm有指令重排的优化，所以代码执行顺序可能是1>3>2，当线程1执行1>3的时候没有执行到2初始化赋值的时候，线程2进入执行，这个时候判断到lazySimple==null,会在创造一个对象，就不是单例了。加了voliate关键字修饰，会因为可见性而防止指令重排，因为其他的线程想要判断lazySimple==null的时候，会在1>2>3执行完成，在线程1修改lazySimple的时候，没写入之前内存像是有屏障一般。这边形成了指令重排无法越过的内存屏障。

3：说说synchronize关键字和voliate关键字

1：voliate修饰变量多线程可见性但是没有原子性，synchronize修饰方法能保证可见性和原子性。

2：voliate的效率更高一点，线程不会阻塞，但是synchronize线程会阻塞

3：voliate用来解决变量的多线程可见性，但是synchronize用来解决多线程资源访问问题

4：lock接口

4.1：为什么需要Lock接口？

我们知道锁是来控制多线程并发访问资源的竞争，在Lock接口出现之前我们使用synchronize关键字来实现锁功能，但是synchronize获取锁是隐式的，我们无法控制锁的获取，释放中断的可操作性性，由于synchronize获取锁固话，所以创建了Lock接口来实现更领过的锁。

Lock和synchronize都是重入锁

1：尝试非中断的获取锁，

2：可以实现中断，与synchronize关键字不同，当获取锁的线程能够响应中断，中断的时候，异常内抛出，释放锁

3：能指定时间获取锁，在指定时间内无法获取锁的时候返回

4.2：代码实现

Lock lock=new ReentrantLock();
		lock.lock();//获取锁
		try {
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			lock.unlock();//finally修饰，异常处理，一定要释放锁
		}

5：ThreadLocal

5.1:ThreadLocal基础案例

多线程的情况下，变量一般都存在一致性问题，有没有线程的专属变量？如果想实现每一个线程都有自己的专属本地变量该如何解决呢？ JDK中提供的ThreadLocal类正是为了解决这样的问题。 ThreadLocal类主要解决的就是让每个线程绑定自己的值，可以将ThreadLocal类形象的比喻成存放数据的盒子，盒子中可以存储每个线程的私有数据。

代码示例如下：

package com.thit.thread1;

public class ThreadLocalTest1 implements Runnable{
   private static  ThreadLocal<String> strings=new ThreadLocal<>();
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ThreadLocalTest1 t=new ThreadLocalTest1();
		Thread t1=new Thread(t);
		t1.start();
		
		System.out.println("main线程获取值:"+strings.get());
		Thread t2=new Thread(new Runnable() {
			
			@Override
			public void run() {
				strings.set("线程22222");
				System.out.println("线程2执行得到ThreadLocal："+strings.get());
				
			}
		});
		t2.start();
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		strings.set("hell oword");
		System.out.println("线程1执行得到ThreadLocal："+strings.get());
	}

}

输出结果如下：不同的线程set，会得到不同的值

5.2:ThreadLocal内存溢出

1:什么事内存泄漏

内存溢出是jvm无法回收某些申请了内存的对象，这些对象长期存在，最终导致内存不够用。一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光

2:thread local为什么会导致内存溢出

弱引用：不管JVM内存资源是否紧张，只要垃圾回收器运行，弱引用所对应的对象就会被释放。

源码：

 static class ThreadLocalMap {

       
        //此处的entity继承弱引用的threadlocal
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;
            //key是弱引用
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }

2.1:如果是强引用

分析: 若果key是threadlocal的强引用

在线程运行中获取了key的值之后线程没有结束的过程中，threadlocal都不会被回收。

在线程结束使用线程池的过程中，线程没有死亡，也不会被回收

2.2:如果是弱引用

分析：在key是threadlocal的弱饮用

在线程运行的过程中没有结束，由于key是弱引用，发生gc的时候，key会被回收，这时候value访问不到。会发生内存泄漏。

在线程结束使用线程池的过程中,线程没有死。key被回收，value访问不到，这时候需要每次使用用remove方法。防止出错

总结：无论是强引用还是弱饮用都无法发避免内存溢出，强引用在线程池的状态下根本无法回收。弱引用存在key被回收value访问不到的情况。但是为啥使用若引用呢。这是因为在所用set get 方法的时候当key被回收的时候，会把value设置为null。这就意味着使用完 ThreadLocal , CurrentThread 依然运行的前提下．就算忘记调用 remove 方法，弱引用比强引用可以多一层保障：弱引用的 ThreadLocal 会被回收．对应value在下一次 ThreadLocaIMap 调用 set/get/remove 中的任一方法的时候会被清除，从而避免内存泄漏．

1 . 没有手动侧除这个 Entry
2 . CurrentThread 当前线程依然运行

浅水壁虎

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
并发基础2（线程方法、synchronize关键字、voliate、lock）

目录0：线程的状态1:多线程的方法1.1：Join()方法1.2：Sleep()方法、wait()、yield()方法同属于Thread方法，不会释放锁1.3：interrupt() 中断方法1.4：wait() 、notifyAll（）、notify()方法（使用在锁方法内部）2：synchronize关键字2.1：说一下对synchronize关键字的...
复制链接

扫一扫