Lock-线程组-线程池-线程状态的转换图

最新推荐文章于 2023-03-16 09:38:42 发布

Luna_ll

最新推荐文章于 2023-03-16 09:38:42 发布

阅读量376

点赞数

分类专栏： JavaSE基础

本文链接：https://blog.csdn.net/Luna_ll/article/details/78749881

版权

JavaSE基础专栏收录该内容

36 篇文章 1 订阅

订阅专栏

一.Lock(接口)

1.使用同步机制的方式解决线程安全问题，但是不知道具体的锁对象在哪里添加，并且锁对象在哪里释放锁对象，对于这种情况，jdk5以后java提供了一个更具体的锁对象

Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作

Lock是一个接口,所以它在使用时用 ReentrantLock子实现类

2.加锁和释放锁的方法：

public void lock()获取锁

public void unlock()试图释放此锁

try{

锁对象.lock()

..........

}finally{

锁对象.unlock() //释放资源

}

package lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SellTickets implements Runnable{
	private static int tickets = 100;
	private Lock lock = new ReentrantLock();
	@Override
	public void run() {
		// 模拟电影院售票,假设一直有票
		while (true){
			//加锁
			try{
				lock.lock();
				
				if(tickets>0){
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets--+"张票");
				}			
			//释放锁	
			}finally{
				lock.unlock();
			}			
		}
	}
}

package lock;

public class SellTicketsDemo {

	public static void main(String[] args) {
		// 创建SynRunnable对象
		SellTickets st = new SellTickets();
		
		//创建线程类对象
		Thread t1 = new Thread(st,"窗口1");
		Thread t2 = new Thread(st,"窗口2");
		Thread t3 = new Thread(st,"窗口3");
		
		//开启线程
		t1.start();
		t2.start();
		t3.start();
	}
}

3.同步机制的优缺点
优点：解决多线程的安全问题

缺点：1)同步，执行效率低（每个线程在抢占到CPU的执行权后，会将门关闭，其他线程不能进来）

2)容易出现死锁：两个或者两个以上的线程出现了互相等待的情况，容易死锁
4.线程间的通信：生产者消费者模式(多个线程对同一资源进行操作)

例子： 1)资源对象:Student类提供一些成员变量:姓名和年龄

2)生产者线程:SetThread类: 生产一些学生数据(设置学生数据)

3)消费者线程:GetThread类: 输出学生数据

4)测试类:StudentDemo类,实现多线程环境

对于生产者来说，产生数据，如果处于等待（wait）状态就说名有数据，通知消费者有线程，赶紧输出数据

对于消费者线程，输出数据，如果没有数据，应该通知生产者产生数据。

以上是一个多线程环境，会出现线程不安全：

1)同一数据打印一片（CPU的一点点时间片足够执行很多此）

2)年龄和姓名不符合（线程的随机性导致的）

使用等待唤醒机制可以解决问题1);使用同步机制可以解决问题2)

package waitnotify;

public class Student {
	String name;
	int age;
	
	//声明一个变量
	boolean flag;//默认没有数据,如果是true,则说明有数据
}

package waitnotify;
//生产者线程
public class SetThread implements Runnable{

	private Student s;
	public SetThread(Student s){
		this.s = s;
	}
	private int i = 0;
	@Override
	public void run() {
		while(true){
			//同步机制可以解决数据不一致
			synchronized(s){
				//等待唤醒机制
				//判断有没有数据
				if(s.flag){  //对于生产者来说，没有数据，则处于等待状态，
					//处于等待状态
					try {
						s.wait();//阻塞方式
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				
				if(i%2==0){
					//设置学生数据
					s.name = "韩庚";
					s.age = 18;
				}else{
					//设置学生数据
					s.name = "张靓颖";
					s.age = 16;
				}
				i++;
				
				//修改标记
				s.flag = true;//有数据
				//通知gt:消费者线程来消费
				s.notify();//唤醒等待状态
			}
			
		}
		
	}

}

package waitnotify;

public class GetThread implements Runnable{
	private Student s;
	public GetThread(Student s){
		this.s = s;
	}
	
	@Override
	public void run() {
		//使用同步机制可以解决数据不一致现象
		while(true){
			synchronized(s){
				
				//使用等待唤醒机制
				if(!s.flag){
					try {
						s.wait();//调用的时候会立即释放锁
					} catch (InterruptedException e) {
		
						e.printStackTrace();
					}
				}
				
			//输出语句
			System.out.println(s.name+"----"+s.age);
			
			//修改标记
			s.flag = false;//消费者线程没有可输出的数据
			
			//通知对方st线程,消费者线程没有数据,赶紧产生数据
			s.notify();		//唤醒st线程
			
			}
		}
	}
}

package waitnotify;

public class StudentDemo {

	public static void main(String[] args) {
		// 创建资源对象
		Student s = new Student();
		
		//创建资源对象
		SetThread st = new SetThread(s);
		GetThread gt = new GetThread(s);
		
		//创建线程类对象
		Thread t1 = new Thread(st);
		Thread t2 = new Thread(gt);
		
		//分别启动线程
		t1.start();
		t2.start();
	}
}

以上例子的成员变量不是私有化，一般成员变量私有化，可以对上面的进行改进

package lastwaitnotify;

public class Student {
	private String name;
	private int age;
	//声明一个变量
	private boolean flag; //默认没有数据,如果是true,则说明有数据
	
	//set(String name,int age)方法，产生数据
	
	//同步机制可以解决数据不一致
	public synchronized void set(String name,int age){
		//等待唤醒机制
		//判断有没有数据
		if(this.flag){  //对于生产者来说，没有数据，则处于等待状态，
			//处于等待状态
			try {
				this.wait();//阻塞方式,立即释放锁 notify
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		//设置学生数据
		this.name = name;
		this.age = age;
	
		//修改标记
		this.flag = true;//有数据
		//通知gt:消费者线程来消费
		this.notify();//唤醒等待状态	
		}
	
	//get()输出数据
	public synchronized void get(){
		if(!this.flag){
			try {
				this.wait() ;//调用的时候,会立即释放锁
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		//输出语句
		System.out.println(this.name+"---"+this.age);
		
		//修改标记
		this.flag = false ;//消费者线程
		//通知对方(st线程),消费者线程没有数据类,赶紧来消费
		this.notify() ;//唤醒t1线程....
		}
	
	}

package lastwaitnotify;
//生产者线程
public class SetThread implements Runnable{

	private Student s;
	public SetThread(Student s){
		this.s = s;
	}
	private int i = 0;
	@Override
	public  void run() {
		while(true){
			if(i%2==0){
				//设置学生数据
				s.set("韩庚", 18);
			}else{
				//设置学生数据
				s.set("张靓颖", 16);
			}
			i++;
		}
	}
}

package lastwaitnotify;

public class GetThread implements Runnable{
	private Student s;
	public GetThread(Student s){
		this.s = s;
	}
	
	@Override
	public void run() {
		
		while(true){
		s.get();
		}
	}
}

package lastwaitnotify;

public class StudentDemo {

	public static void main(String[] args) {
		// 创建资源对象
		Student s = new Student();
		
		//创建资源对象
		SetThread st = new SetThread(s);
		GetThread gt = new GetThread(s);
		
		//创建线程类对象
		Thread t1 = new Thread(st);
		Thread t2 = new Thread(gt);
		
		//分别启动线程
		t1.start();
		t2.start();

	}

}

二.线程组（ThreadGroup）
表示一个线程的集合

1.public final ThreadGroup getThreadGroup()返回该线程的线程组

2.public ThreadGroup(String name)设置线程组名称

3.public Thread(ThreadGroup,Runnable target,String name)给每一个子线程设置线程组名称

package threadgroup;

public class ThreadGroupDemo {
	public static void main(String[] args) {
		//线程组:一个线程的集合
		method1();
		method2();
	}
	//给每一个子线程设置线程名称
	private static void method2() {
		
		//public ThreadGroup(String name)构造一个新线程组
		
		ThreadGroup tg = new ThreadGroup("这是一个新的线程组") ;
		
		//创建资源对象
		MyRunnable t1 = new MyRunnable();
		
		//创建线程类对象,并且将线程组对象作为参数进行传递,就使用Thread类的构造方法
		//public Thread(ThreadGroup group,Runnable target ,String name){}
		Thread th1 = new Thread(tg, t1, "线程1") ;
		Thread th2 = new Thread(tg, t1, "线程2") ;
		
		//public final ThreadGroup getThreadGroup()返回该线程的线程组
		ThreadGroup tg1 = th1.getThreadGroup() ;
		ThreadGroup tg2 = th2.getThreadGroup() ;
		
		System.out.println(tg1.getName());
		System.out.println(tg2.getName());
		
		tg.setDaemon(true) ;//将线程组中的所有的线程都设置为守护线程(后台线程)
		
	}

	private static void method1() {
		// 获取多个线程所在的线程组名称
		
		//创建资源对象
		MyRunnable tg = new MyRunnable();
		
		//创建线程类对象
		Thread t1 = new Thread(tg);
		Thread t2 = new Thread(tg);
		
		//获取t1和t2所在的线程名称
		//获取线程组对象
		//public final ThreadGroup getThreadGroup()返回该线程所属的线程组
		 ThreadGroup tg1 = t1.getThreadGroup();
		 ThreadGroup tg2 = t2.getThreadGroup();
		 
		 String name1 = tg1.getName();
		 String name2 = tg2.getName();
		 
		 //子线程默认的线程组名称:main线程
		 System.out.println(name1);//main
		 System.out.println(name2);//main
		 
		 //所有的线程它的默认线程组名称就是main
		 System.out.println(Thread.currentThread().getThreadGroup().getName());
	}

}

package threadgroup;

public class MyRunnable implements Runnable {

	@Override
	public void run() {
		while(true){
			for(int i=0;i<100;i++){
				System.out.println(Thread.currentThread().getName()+"---"+i);
			}
		}		
	}	
}

三.线程池
线程池的好处:节约成本,很多子线程调用完毕不会立即被回收掉,而是会回到线程池中被多次利用!
JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法

1)public static ExecutorService newFixedThreadPool(int nThreads)

Executors工厂类中的这个方法参数直接指定在当前线程池中有多少个线程
这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。

ExecutorsService :接口中的方法

2)Future<?> submit(Runnable task)

<T> Future<T> submit(Callable<T> task)

package threadpool;

public class MyRunnable implements Runnable {

	@Override
	public void run() {
		while(true){
			for(int i=0;i<100;i++){
				System.out.println(Thread.currentThread().getName()+":"+i);
			}
		}

	}

}

package threadpool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorDemo {
	public static void main(String[] args) {
		//创建线程池对象
		//public static ExecutorService newFixedThreadPool(int nThreads)
		ExecutorService pool = Executors.newFixedThreadPool(2);
		
		//使用submit(Runnable target):提交多个任务
		pool.submit(new MyRunnable());
		pool.submit(new MyRunnable());
		
		//结束线程池
		pool.shutdown();		
		
	}
}

多线程实现的方式三（实际开发中很少用）

创建线程池对象实现callable接口

package callable;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 多线程程序的实现方式3:(实际开发中很少用到!)
 * 	public static ExecutorService newFixedThreadPool(int nThreads)
				Executors工厂类中的这个方法参数直接指定在当前线程池中有多少个线程
		这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnabl	e对象或者Callable对象代表的线程。它提供了如下方法
		
		ExecutorsService :接口中的方法
		<T> Future<T> submit(Callable<T> task)
 * @author Apple
 */
public class CallableDemo {

	public static void main(String[] args) {
		// 创建线程池对象
		ExecutorService threadpool = Executors.newFixedThreadPool(2);
		
		//提交Callable任务
		threadpool.submit(new MyCallable());
		threadpool.submit(new MyCallable());
		//结束线程池
		threadpool.shutdown();

	}

}

package callable;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Object> {

	@Override
	public Object call() throws Exception {
		for(int i=0;i<100;i++){
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
		return null;
	}

}

四.多线程中的匿名内部类的方式

格式：new 类名(具体类,抽象类),接口(){
重写/实现方法;
}

匿名内部类的本质:继承了该类或者是实现该接口的子类对象!

public class ThreadDemo {
	public static void main(String[] args) {
		
		//继承自Thread类
		new Thread(){
			@Override
			public void run() {
				//for循环
				for(int x = 0 ; x <100 ; x ++){
					System.out.println(Thread.currentThread().getName()+":"+x);
				}
			}
		}.start() ;//启动线程
		
		
		//Runnable接口的方式
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				//for循环
				for(int x = 0 ; x < 100 ; x ++){
					System.out.println(Thread.currentThread().getName()+":"+x);
				}
			}
		}).start() ;
}

五.定时器Timer

常用的方法：

public void schedule(TimerTask task,Date time)安排在指定的时间执行指定的任务

public void schedule(TimerTask task, long delay)在多少毫秒后执行指定任务

public void schedule(TimerTask task, long delay, long period)在多少毫秒后,执行任务,并且每个多少毫秒重复执行

public void cancel()终止此计时器，丢弃所有当前已安排的任务

TimeTask是一个抽象类，自定义一个类实现它

练习：在指定的时间内删除当前项目下Demo文件夹中的内容

package timer;

import java.io.File;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class TimerTest {

	public static void main(String[] args) throws ParseException {
		//创建Timer定时器
		Timer t = new Timer();
		
		//定义一个文本日期格式
		String dateStr = "2017-12-8 16:50:00";
		//解析成Date对象
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		//解析方法
		Date date = sdf.parse(dateStr);
		
		//public void schedule(TimerTask task,Date time)安排在指定的时间执行指定的任务
		//调用定时器在指定的时间内执行某个任务
		t.schedule(new DeleteFolder(), date);
		
		

	}

}
//删除Demo文件夹
class DeleteFolder extends TimerTask{

	@Override
	public void run() {
		// 封装当前项目下的Demo文件
		File srcFolder = new File("demo");
		deleteFolder(srcFolder);
	}
	
	//递归删除
	private void deleteFolder(File srcFolder) {
		// 获取当前strFolder下面的所以文件及文件夹
		File[] fileArray = srcFolder.listFiles();
		//对该对象非空判断
		if(fileArray!=null){
			//增强for遍历
			for(File file : fileArray){
				//判断file对象是否是文件夹
				if(file.isDirectory()){
					//继续回到删除目录的方法
					deleteFolder(file);
				}else{
					//不是目录,是文件直接删除
					System.out.println(file.getName()+"---"+file.delete());
				}
			}
			System.out.println(srcFolder.getName()+"---"+srcFolder.delete());
		}
		
	}
	
}

Luna_ll

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Lock-线程组-线程池-线程状态的转换图

一.Lock(接口)1.使用同步机制的方式解决线程安全问题，但是不知道具体的锁对象在哪里添加，并且锁对象在哪里释放锁对象，对于这种情况，jdk5以后java提供了一个更具体的锁对象Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作Lock是一个接口,所以它在使用时用 ReentrantLock子实现类2.加锁和释放锁的方法：pu
复制链接

扫一扫