线程

线程篇(主线程(UI线程),后台线程,线程池线程) 后续不间断增加、提示:以下是本篇文章正文内容,下面案例可供参考总之,不同的线程类型适用于不同的场景,我们需要根据具体的需求来选择合适的线程类型。在使用线程时,我们需要注意线程的生命周期、同步机制、异常处理、性能优化等方面的问题,以保证线程的稳定性和可靠性。 阅读详情

程序:可以理解为一组静态的代码
进程:正在进行的程序
线程:正则执行线程的小单元

多线程
线程允许我们并发执行多个代码片段。

创建线程有两种方式,
方式一:
定义一个类继承Thread并重写run方法。run方法用来定义需要线程并发执行的任务代码
第二种创建线程的方式:实现Runnable接口单独定义线程任务
第一种创建线程的方式
优点:创建简单,当临时需要执行某个任务时使用这种方式创建更直接
缺点:由于java是单继承的,这会导致我们继承了线程以后就不能再继承其他类去复用方法,实际开发非常不便

定义线程的同时重写run方法,将任务也一同定义出来这会导致线程与任务有一个必然耦合关系,不利于线程的重用。

注意,启动线程要调用start,而不是直接调用run方法。
start方法调用完毕后,线程纳入线程调度器。当该线程第一次获得CPU时间开始运行时,其run方法
会自动被调用。

线程纳入线程调度器后,只能被动的等待分配CPU的时间片,得到时间片后,CPU便会运行该线程的任务代码,时间片用完后,CPU离开,此时线程调度会再分配时间片给某个线程使其运行。

线程调度器分配时间片的概率是一样的,但是所有并发运行的线程不保证"一人一次"这样均匀的分配
时间片。

匿名内部类实现线程
			Thread t1 = new Thread() {
				public void run() {
					for (int i = 0; i < 20; i++) {
						System.out.println("Thread"+i);
					}
					
				};
			};
			Runnable r1 = new Runnable() {
				@Override
				public void run() {
					for (int i = 0; i < 20; i++) {
						System.out.println("Runnable"+i);
					}
				}
			};
			t1.start();
			new Thread(r1).start();

生产消费者模型

仓库类

public class Cangku {

	private ArrayList<Integer> list = new ArrayList<Integer>();

	public void add() {

		if (list.size() < 20) {
			list.add(1);
			System.out.println("++++");
		}else {
			return;
		}
	}
	public void remove() {

		if (list.size() > 0) {
			list.remove(0);
			System.out.println("------");
		} else {
			return;
		}
	}

}

生产者

public class Sheng extends Thread{

	public Sheng(Cangku cangku) {
		super();
		this.cangku = cangku;
	}

	private Cangku cangku;
	
	@Override
	public void run() {
		while(true) {
			cangku.add();
		}
	}
	
}

消费者

public class Xiao extends Thread{

	public Xiao(Cangku cangku) {
		super();
		this.cangku = cangku;
	}

	private Cangku cangku;
	
	@Override
	public void run() {
		while(true) {
			cangku.remove();
		}
	}
	
}

main

public static void main(String[] args) {
		Cangku cangku = new Cangku();
		Sheng sheng = new Sheng(cangku);
		sheng.start();
		Xiao xiao = new Xiao(cangku);
		xiao.start();
		Xiao xiao1 = new Xiao(cangku);
		xiao1.start();
	}

产生问题

	两个消费者同时访问一个仓库对象,仓库内只有一个元素时,两个消费者并发访问,有可能产生抢夺资源的问题

解决
让仓库对象被线程访问时,仓库对象被锁定
让仓库对象只能被一个对象访问,其他线程处于等待状态,即同一个时间点只有一个线程访问
特征修饰符:synchronized
两种写法

写在方法的结构上(锁定的时调用方法时的那个对象)

public synchronized void remove() {

写在方法/构造方法/块的内部

					public void test(){
						//代码一
						
						synchronized (this){
							//代码二
						}
						//代码三							
					}

最终解决,添加线程安全锁,让线程等待或唤醒

public class Cangku {

	private ArrayList<Integer> list = new ArrayList<Integer>();

	public void add() {

		if (list.size() < 20) {
			list.add(1);
			System.out.println("++++");
		} else {
			try {
				/**
				 * 当线程等后,要叫醒其他的线程,否则可能出现所有线程都等待的结果
				 */
				// 叫醒其他所有的线程
				this.notifyAll();
				// 仓库对象调用wait不是仓库等待,而是访问仓库的生产者线程等待
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	public void remove() {

		if (list.size() > 0) {
			list.remove(0);
			System.out.println("------");
		} else {
			try {
				// 叫醒其他所有的线程
				this.notifyAll();
				// 仓库对象调用wait不是仓库等待,而是访问仓库的消费者线程等待
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

}

注意

当没有线程安全锁时,调用 wait();方法,可能抛出异常

IllegalMonitorStateException

是因为当通知一个人等待是,线程切换了,被通知的那个人已经不是刚才的那个线程了
此时,如果有线程安全锁,就不会产生问题了

总结

利用了线程安全锁,锁定的是对象
利用方法控制线程状态来回切换

笔试题

slepp方法是Thread类下的,方法是静态的,类名.调用,在哪个位置调用,哪个位置等待,自己就可以醒,不会释放锁
wait方法是Object下的,通过对象.调用,是让访问对象的其他线程等待。需要其他对象调用notify唤醒,等待后会释放锁

join方法

线程的API

线程提供了一个静态方法:
static Thread currentThread()
这个方法会将运行这个方法的线程返回。
一个重要的API:ThreadLocal会使用到它。

static Thread currentThread()
返回对当前正在执行的线程对象的引用。

	Thread t1 = Thread.currentThread();
		//Thread[线程名字,线程优先级,线程组]
		//Thread[main,5,main]
		System.out.println(t1);
		new Thread() {
			@Override
			public void run() {
				//Thread[Thread-0,5,main]
				System.out.println(Thread.currentThread());
			}
		}.start();
		// 获取主线程
		Thread main = Thread.currentThread();
		// 获取线程的唯一标识
		long id = main.getId();
		System.out.println("id:" + id);
		// 获取线程名字
		String name = main.getName();
		System.out.println(name);
		// 获取线程的优先级,默认情况线程的优先级都是5
		int priority = main.getPriority();
		System.out.println(priority);
		// 线程是否处于活动状态
		boolean isAlive = main.isAlive();
		// 线程是否为守护线程
		boolean isDaemon = main.isDaemon();
		// 线程是否被中断
		boolean isInterrupted = main.isInterrupted();
		System.out.println("isAlive:" + isAlive);
		System.out.println("isDaemon:" + isDaemon);
		System.out.println("isInterrupted:" + isInterrupted);

线程优先级

线程启动后纳入到线程调度,线程时刻处于被动获取CPU时间片而无法主动获取。我们可以通过调整线程的优先级来最大程度的干涉线程调度分配时间片的几率。
理论上优先级越高的线程获取CPU时间片的次数越多。

线程优先级有10个等级,分别用整数1-10表示。其中1位最低优先级,10为最高优先级,5为默认值。

调用线程的方法:setPriority()方法来设置优先级。

/**
		* 线程提供的方法:
		* static void sleep(long ms)
		* 这是一个静态方法,当一个线程执行了这个方法后就会进入
		* 阻塞状态,并阻塞指定的毫秒。当超时后,线程会自动回到
		* RUNNABLE状态等待再次获取时间片并发运行。
		*/
		/**
		* sleep方法要求处理中断异常:InterruptedException
		* 当一个线程调用sleep方法处于阻塞状态的过程中,这个线程
		* 的中断方法interrupt被调用时,则sleep方法会抛出中断异常
		* 此时该线程的睡眠阻塞被打断。
		* @author Administrator
		*/
		处理中断异常:InterruptedException
		public static void main(String[] args) {
			Thread lin = new Thread() {
				public void run() {
					System.out.println("林:刚美完容,睡一会...");
					try {
						Thread.sleep(10000);
					} catch (InterruptedException e) {
						System.out.println("林:干嘛呢!干嘛呢!干嘛呢!都破了相了!");
					}
					System.out.println("林:醒了!");
				}
			};
			Thread huang = new Thread() {
				public void run() {
					System.out.println("黄:开始砸墙!");
					for(int i=0;i<5;i++) {
						System.out.println("黄:80!");
						try {
							Thread.sleep(1000);
						} catch (InterruptedException e) {
						}
					}
					System.out.println("咣当!");
					System.out.println("黄:搞定!");
					lin.interrupt();//中断lin线程的睡眠阻塞
				}
			};
			
			lin.start();
			huang.start();
		}
	/**
	* 守护线程
	* 设置守护线程必须在线程启动之前设置
	* 守护线程又称为后台线程,默认创建出来的线程都是普通线程。
	* 守护线程需要通过调用线程方法:setDaemon(boolean on)来
	* 进行设置。
	* 
	* 守护线程使用上与普通线程没有区别,但是在结束时机上有一个
	* 不同之处:进程结束时,所有正在运行的守护线程都会被强制停
	* 止。而进程结束:当一个进程中所有的普通线程结束时进程结束
	* 
	* GC就是跑在守护线程上的。
	* 我们也可以将某些会一致运行的任务,并且当主要业务执行完毕
	* 后可以跟着一同结束的就都放在守护线程上运行即可。
	* 
	* @author Administrator
	*
	*/
	守护线程
public class DaemonThreadDemo {
			public static void main(String[] args) {
				Thread rose = new Thread() {
					public void run() {
						for(int i=0;i<5;i++) {
							System.out.println("rose:let me go!");
							try {
								Thread.sleep(1000);
							} catch (InterruptedException e) {
							}
						}
						System.out.println("rose:啊啊啊啊AAAAAaaaaa....");
						System.out.println("噗通!");
					}
				};
				
				Thread jack = new Thread() {
					public void run() {
						while(true) {
							System.out.println("jack:you jump!i jump!");
							try {
								Thread.sleep(1000);
							} catch (InterruptedException e) {
							}
						}
					}
				};
				
				
				rose.start();
				
				//线程启动前进行设置
				jack.setDaemon(true);//设置为守护线程
				
				jack.start();
				//此时如果是死循环,主线程没有死,则守护线程不能结束
				//如果不添加死循环,rose停止了则jack也会停止
				while(true) {
					
				}
			}
		}

join:让线程完成排队

public class A extends Thread {
	@Override
	public void run() {
		System.out.println("线程a开始执行");
		//在线程a里创建b线程,
		B b = new B();
		b.start();
		try {
			//如果不传递参数,表示a线程会一直等待B线程执行完
			//如果传递参数,表示a线程等待b线程的最多时间,如果在时间内b线程结束了,则a继续执行
			//如果时间内b线程没有结束,则a直接执行
			//这里如果c锁定了b,则a会等待c释放b然后a自己才能执行完
			b.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("线程a结束执行");
	}

}
public class B extends Thread{

	@Override
	public void run() {
		System.out.println("线程b开始执行");
		new C(this).start();;
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("线程b结束执行");
	}
	
}
public class C extends Thread {
	
	private B b;
	
	public C(B b) {
		this.b = b;
	}
	
	@Override
	public void run() {
		System.out.println("线程c开始执行");
		//锁定b五秒
		synchronized (b) {
			try {
				Thread.sleep(5000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("线程c结束执行");
	}

}
public static void main(String[] args) {
		new A().start();
	}



		public class ThreadTest extends Thread {
			static boolean b = false;
			public static void main(String[] args) {
				/**
				 * 线程提供了一个方法:
				 * void join()
				 * 该方法允许执行这个方法的线程在该方法所属线程后等待,
				 * 直到该方法所属线程结束后方可继续运行,否则会一致处于
				 * 阻塞状态。
				 * 所以join可以协调线程之间的同步运行。
				 * 同步运行:执行有先后顺序
				 * 异步运行:执行没有先后顺序,多线程就是异步运行的。
				 * @author Administrator
				 *
				 */
				/*
				 * JDK8之前有一个强制要求(JDK8不强制要求,但是
				 * 若存在使用不当情况,编译器仍然会编译失败)。
				 * 当一个方法的局部内部类中引用了这个方法的其他
				 * 局部变量时,要求这个变量必须声明为final的。
				 * 这源自JVM的内存分配问题。
				 */
			
				final Thread t1 = new Thread() {
					public void run() {
						for(int i=1;i<=10;i++) {
							System.out.println("图片下载了"+i);
							try {
								Thread.sleep(100);
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}
						b = true;
					}
				};
				Thread t2 = new Thread() {
					public void run() {
						//解决:此时应该卡住t2线程,等待t1线程执行完
				//想把谁卡住,就让谁调join方法,等着哪个线程就调哪个线程的join
				try {
					t1.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				if(b) {
					System.out.println("图片显示成功");
				}else {
					System.out.println("图片显示失败");
					throw new RuntimeException("图片显示失败");							
				}
				}
			};
			t1.start();
			t2.start();
			}
		}

哲学家就餐问题

public class Kuaizi extends Thread {
	private int num;

	public int getNum() {
		return num;
	}

	public void setNum(int num) {
		this.num = num;
	}

	public Kuaizi(int num) {
		super();
		this.num = num;
	}
	

}
public class Zhexuejia extends Thread{

	
	public Zhexuejia(String name, Kuaizi zuo, Kuaizi you) {
		super();
		this.name = name;
		this.zuo = zuo;
		this.you = you;
	}
	private String name;
	private Kuaizi zuo;
	private Kuaizi you;
	@Override
	public void run() {
		synchronized (zuo) {
			System.out.println(name+"获得左手的筷子");
			synchronized (you) {
				System.out.println(name+"获得右手的筷子");
				System.out.println(name+"......");				
			}
		}
	}
}
public static void main(String[] args) {
		Kuaizi kuaizi1 = new Kuaizi(1);
		Kuaizi kuaizi2 = new Kuaizi(2);
		Kuaizi kuaizi3 = new Kuaizi(3);
		Kuaizi kuaizi4 = new Kuaizi(4);
		Zhexuejia zhexuejia1 = new Zhexuejia("张1三",kuaizi1,kuaizi2);
		Zhexuejia zhexuejia2 = new Zhexuejia("张2三",kuaizi2,kuaizi3);
		Zhexuejia zhexuejia3 = new Zhexuejia("张3三",kuaizi3,kuaizi4);
		Zhexuejia zhexuejia4 = new Zhexuejia("张4三",kuaizi4,kuaizi1);
		zhexuejia1.start();
		zhexuejia2.start();
		zhexuejia3.start();
		zhexuejia4.start();
	}

可能会产生死锁的问题

解决,增加排队的机制

public Zhexuejia(String name, Kuaizi zuo, Kuaizi you,long time) {
		super();
		this.name = name;
		this.zuo = zuo;
		this.you = you;
		this.time = time;
	}
	private String name;
	private Kuaizi zuo;
	private Kuaizi you;
	private long time;
	
	@Override
	public void run() {
		try {
			Thread.sleep(time);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		synchronized (zuo) {
			System.out.println(name+"获得左手的筷子");
			synchronized (you) {
				System.out.println(name+"获得右手的筷子");
				System.out.println(name+"......");				
			}
		}
	}

同时创建Zhexuejia对象需要在传递一个时间参数

并发安全问题的介绍
同步锁
/**
 * 多线程并发安全问题
 * 当多个线程并发操作同一个资源(临界资源)时,由于线程切换
 * 实际不确定,导致执行此操作的顺序混乱,会出现执行过程
 * 与结果未按照该程序预定方式进行导致一系列后果,严重时可
 * 能导致系统瘫痪。
 * @author Administrator
 *
 */
产生了抢资源的问题	 
public class ThreadTest extends Thread {
		public static void main(String[] args) {
			final Table table = new Table();
			Thread t1 = new Thread() {
				public void run() {
					while(true) {
						int bean = table.getBean();
						Thread.yield();//模拟CPU时间片用完导致线程切换
						System.out.println(getName()+":"+bean);
					}
				}
			};
			Thread t2 = new Thread() {
				public void run() {
					while(true) {
						int bean = table.getBean();
						Thread.yield();//模拟CPU时间片用完导致线程切换
						System.out.println(getName()+":"+bean);
					}
				}
			};
			t1.start();
			t2.start();
		}
	}
	class Table {
		int beans = 20;
		解决方式一
		/**
		 * 当一个方法使用关键字synchronized修饰后,这个方法
		 * 称为"同步方法",即:多个线程不能同时进到方法内部执
		 * 行。
		 * 将多个线程并发执行操作临界资源改为同步执行就可以
		 * 有效的解决多线程的并发安全问题。
		 * 直接在方法上使用synchronized,那么同步监视器对象就是"this",即:该方法所属对象
		 * @return
		 */
		public synchronized int getBean() {
			if(beans==0) {
				throw new RuntimeException("没有豆子了!");
			}
			Thread.yield();//模拟CPU时间片用完导致线程切换
			return beans--;
		}
	}
解决方式二
/**
 * 同步块:
 * synchronized(同步监视器对象){
 * 	需要同步运行的代码片段
 * }
 * 
 * 同步块可以更准确的控制需要同步运行的代码片段,有效的
 * 缩小同步范围可以保证并发安全的前提下尽可能的提高并发
 * 的效率。
 * 
 * 同步块要求指定一个同步监视器对象,即:上锁
 * 的对象。这个对象可以是java中任何对象,但是
 * 必须保证多个需要同步运行此代码片段的线程看到
 * 的该对象是"同一个"。
 */
	 //	public synchronized void buy() {
	public void buy() {
		Thread t = Thread.currentThread();
		try {
			System.out.println(t.getName()+":正在挑衣服...");
			Thread.sleep(5000);
			/*
			 * 同步块要求指定一个同步监视器对象,即:上锁
			 * 的对象。这个对象可以是java中任何对象,但是
			 * 必须保证多个需要同步运行此代码片段的线程看到
			 * 的该对象是"同一个"。
			 */
			synchronized (this) {
				System.out.println(t.getName()+":正在试衣服...");
				Thread.sleep(5000);
			}
			System.out.println(t.getName()+":结账离开");			
		} catch (Exception e) {
		}
	}
/**
 * 静态方法若使用synchronized修饰,那么这个方法一定
 * 具有同步效果。
 * 静态方法上使用的同步监视器对象为这个类的"类对象",
 * 每个java定义的类都只有唯一的一个类对象(Class类型的的实
 * 例),而类对象后面的反射知识中会介绍。
 * 
 * 静态方法中若使用同步监视器对象,也可以使用
 * 当前类的类对象,获取当前类的类对象可以直接
 * 通过:类名.class得到。如下:
 */
互斥锁
/**
 * 互斥锁
 * 当使用synchronized锁定多个代码片段,并且他们指定的
 * 同步监视器对象是同一个时,那么这些代码片段之间就是互斥
 * 的,多个线程不能同时在这些代码片段中运行。
 */
	public class SyncDemo4 {
		public static void main(String[] args) {
			Boo boo = new Boo();
			Thread t1 = new Thread() {
				public void run() {
					boo.methodA();
				}
			};
			Thread t2 = new Thread() {
				public void run() {
					boo.methodB();
				}
			};
			t1.start();
			t2.start();
		}
	}
	
	class Boo{
		public synchronized void methodA() {
			try {
				Thread t = Thread.currentThread();
				System.out.println(t.getName()+":正在执行A方法...");
				Thread.sleep(5000);
				System.out.println(t.getName()+":执行A方法完毕!");
			} catch (Exception e) {
			}
		}
		public void methodB() {
			synchronized(this) {
				try {
					Thread t = Thread.currentThread();
					System.out.println(t.getName()+":正在执行B方法...");
					Thread.sleep(5000);
					System.out.println(t.getName()+":执行B方法完毕!");
				} catch (Exception e) {
				}
			}
		}
	}
Linux 线程:使用&管理线程、多线程、分离线程 阅读详情

相关推荐

线程池的线程是如何复用的

进程和线程的关系相信大家都知道,这里我就不做过多的解释了,既然一个进程是由多个线程组成的,那么线程池又是由若干个线程队列组成的,在并发量比较高的情景下,我们通常会去创建线程池就执行任务,而不单一的创建多个线程去执行任务,因为线程的创建的一系列动作,是需要资源开销的,如果频繁的对线程创建销毁,其实本身是一种很浪费资源的,就更谈不上提高效率了。

m0_71777195的博客 2538

创建线程的三种方式,线程的方法,线程的优先级

面试题:进程和线程的区别? 进程是操作系统资源分配的基本单位,而线程是处理器任务调度和执行的基本单位。 一个进程可以包含多个线程,而且至少包含一个线程。 地址空间:进程有自己独立的地址空间,每启动一个进程,系统都会为其分配地址空间, 线程没有独立的地址空间,同一进程的线程共享本进程的地址空间。 资源拥有:进程之间的资源是独立的,同一进程内的线程共享本进程的资源。 执行过程:每个独立的进程有一个程序运行的入口、程序执行序列和程序入口。 但是线程不能独立执行,必须依附在应用程序中,由应用程序提供多个线程执行控.

weixin_48058125的博客 432

前台线程和后台线程、用户线程和守护线程

一、Java 分为两种线程:用户线程和守护线程 所谓守护线程是指在程序运行的时候在后台提供一种通用服务的线程,比如垃圾回收线程就是一个很称职的守护者,并且这种线程并不属于程序中不可或缺的部分。因 此,当所有的非守护线程结束时,程序也就终止了,同时会杀死进程中的所有守护线程。反过来说,只要任何非守护线程还在运行,程序就不会终止。 守护线程和用户线程的没啥本质的区别:唯一的不同之处就在于虚拟机的离开:...

程序员世杰 2746

2019年java面试题_2019年最新Java基础面试题及面试技巧

面试是件既简单又复杂的事情,也正是因为简单和复杂的两面性,所以Java程序员在面试的时候要多学些面试技巧,当然技术也不能落下,如果你觉得各方面都准备妥当,但差点火候,我觉得你看完这篇能更好的发挥你的潜力。我们先来说说面试技巧一、简历的制作一定要突出个人特色,千篇一律的简历HR手中一大把,这样的简历他们看都不会看。二、回答问题拿捏好分寸,如果这个问题你真的不知道,那你就坦诚的说:“我不知道,但我觉得...

weixin_36125467的博客 256

【遥感数字图像处理(朱文泉)】第四章 变换域处理方法

变换域的处理方法

甜子yu的博客 4312

Mac上VMware Fusion手动安装VMware Tools实现跨系统复制粘贴

本文详细指导了在Mac的VMware Fusion中手动安装VMware Tools的完整流程,以解决虚拟机与宿主机之间无法复制粘贴的常见问题。通过定位安装镜像、挂载、解压并运行安装脚本,最终实现跨系统无缝数据交换,提升工作效率。

orange的博客 701

java线程直接调用run_直接调用线程的run方法是否可以启动线程?

首先Thread类中run()和start()方法的区别如下:run()方法:在本线程内调用该Runnable对象的run()方法,可以重复多次调用;start()方法:启动一个线程,调用该Runnable对象的run()方法,不能多次启动一个线程;public class Test implements Runnable{public static void main(String[] args...

weixin_42510053的博客 2956

WPF进阶 | 深入 WPF 依赖项属性:理解其强大功能与应用场景

WPF进阶 | 深入 WPF 依赖项属性:理解其强大功能与应用场景,在 Windows Presentation Foundation(WPF)开发中,依赖项属性是一个核心且强大的特性,它为构建灵活、可扩展的用户界面提供了关键支持。理解并熟练运用依赖项属性,对于开发高效、健壮的 WPF 应用程序至关重要。本文将深入探讨 WPF 依赖项属性,通过丰富的代码示例和对关键概念的详细解释,帮助读者全面掌握这一重要特性及其应用场景。

不踩坑,不知道坑有多深;不总结,踩过的坑白踩。 4万+

线程Thread类的start()方法和run()方法

一、初识 java的线程是通过java.lang.Thread类来实现的。VM启动时会有一个由主方法所定义的线程。可以通过创建Thread的实例来创建新的线程。每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的,方法run()称为线程体。通过调用Thread类的start()方法来启动一个线程。 在Java当中,线程通常都有五种状态,创建、就绪、运行、阻塞和死亡。   ...

别抢我蓝buff 5337

Keras中神经网络可视化模块keras.utils.visualize_util安装配置方法

Keras中神经网络可视化模块keras.utils.visualize_util安装配置方法

jacke121的专栏 2759

基于Transformer模型实现交通流量时序预测(PyTorch版)

Transformer模型,作为一种基于自注意力机制的深度学习模型,最初在自然语言处理领域取得了突破性进展,其出色的长距离依赖关系捕捉能力使其在处理时序数据时也表现出色。将Transformer模型应用于交通流量时序预测,可以充分利用其优势,实现对交通流量更加精准、高效的预测。

时序笔记 2575

聊聊线程之run方法

话不多说 参考书籍 汪文君 补充知识:start是异步,run是同步,start的执行会经过JNI方法然后被任务执行调度器告知给系统内核分配时间片进行创建线程并执行,而直接调用run不经过本地方法就是普通对象执行实例方法。 什么是线程? 1.现在几乎百分之百的操作系统都支持多任务的执行,对计算机来说每一个人物就是一个进程(Process),在每一个进程内部至少要有一个线程实在运行中,有时线...

以爱护甲,爱满枫林。 2714

畅游Diffusion数字人(0):专栏文章导航

畅游Diffusion数字人(0):专栏文章导航

沉迷单车的追风少年 1426

线程及线程池

本文章主要讲解线程及线程池部分的相关知识

2301_80365603的博客 1963

YOLOv11改进策略【SPPF】| AIFI : 基于Transformer的尺度内特征交互,在降低计算成本的同时提高模型的性能

本文记录的是基于AIFI模块的YOLOv11目标检测改进方法研究。AIFI是RT-DETR中高效混合编码器的一部分,利用其改进YOLOv11模型,

Limiiiing的博客 2241

后仿真中《SDF反标必懂连载篇》之 Negative Delay (理论篇)

今天,学习一下SDF文件中的负数延时问题。比如下面的图片中的SETUPHOLD 中的hold time 为负数。

那么菜的博客 2580

一键了解线程、线程安全、线程池

一键了解线程、线程安全、线程池

HKTTT_的博客 2039

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

linux线程详解:线程概念、线程调度、线程安全、线程模型

(1)线程的组成:线程ID、当前指令指针(PC)、寄存器集合、堆栈;(2)一个进程包含一个或者多个线程,其中进程的大部分资源(代码段、数据段、堆段、打开文件/信号等)都是线程间共享的,线程会保留一部分私有数据(寄存器、栈);

weixin_42031299的博客 3584

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

多线程,线程池,线程的创建,线程池的参数

​ 进程是处于运行过程中的程序,并且具有一定的独立功能,进程是系统进行资源分配和调度的一个独立单位。线程也被称为轻量级进程,线程是进程的组成部分,一个进程可以拥有多个线程,一个线程必须有一个父进程。线程可以拥有自己的堆栈、自己的程序计数器和自己的局部变量,但不拥有系统资源,它与父进程的其它线程共享该进程所拥有的全部资源。一个线程可以创建和撤销另一个线程,同一个进程中的多个线程之间可以并发执行。

weixin_44797327的博客 1306

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

易语言创建线程挂起线程恢复线程销毁线程

线程创建CreateThread,线程挂起SuspendThread,线程恢复ResumeThread,线程销毁TerminateThread,都是kernel32的命令,我们自己封装这些线程的命令,就是便于我们理解他们的工作机制。 API源码: .版本 2 .DLL命令 恢复线程, 整数型, "kernel32", "ResumeThread", , 恢复线程 .参数 hThread, 整数型, , 线程的句柄 .DLL命令 销毁线程, 整数型, "kernel32", "Termi

511遇见 1万+

JAVA线程、线程池解析

是操作系统能够进行的最小单位,它被包含在进程之中,是进程中的实际运作单位。进程是资源分配的基本单位,它拥有自己独立的地址空间和各种资源;而线程是处理机调度的基本单位,它只能和其他线程共享进程的资源,而。线程的上下文切换速度比进程快。

柔丽君的博客 1413

线程 - 线程优缺点、线程自有和共享的数据、多线程使用公共空间、线程分离、线程库对线程的管理

在上面的【四、2. 线程自有的数据】部分,我们提及了线程有独立栈结构,现在我们看到它了, 线程的栈结构是在库中维护的,每个线程都有自己的独立栈结构,主线程使用的是地址空间中的栈空间,叫主线程栈。多线程切换有成本,像上面的计算密集型应用,线程过多可能会有较大的性能损失(增加了额外的同步和调度开销,而可用资源不变)。而进程创建的时空成本是较高的,有各种数据结构的创建,数据的加载。让两个线程进同一个线程函数,打印同一个临时变量的地址,是不一样的,说明使用的是不同的栈结构。而线程占用的都是一份的。

addicted_to的博客 1385

多线程——线程实现、线程状态、线程同步、线程通信、线程池

多线程一、线程1.普通方法调用和多线程2.程序、进行、线程二、线程创建1.继承Thread类2.实现Runable接口3.实现Callable接口4.静态代理模式5、Lamda表达式三、线程状态1.线程状态2.线程方法3.线程停止4.线程休眠sleep5.线程礼让5.join6.线程状态观测7.线程优先级8.守护(daemon)线程四、线程同步1.并发与并行2.线程同步——等待机制2.1 队列 和 锁2.2 线程同步2.3 同步方法2.4 同步块3.死锁4. Lock锁 一、线程 1.普通方法调用和多线程

weixin_44090845的博客 3772

Linux-多线程2 ——线程等待、线程异常、线程退出、线程取消和线程分离

提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档。

fengjunziya的博客 1431

[线程]等待一个线程, 获取当前线程引用,休眠当前线程, 线程的六种状态

我们知道, 多个线程的调度顺序是无序的, 谁先被调度不确定, 谁先结束也不确定, 所以我们引入线程等待, 可以控制线程结束的先后顺序 上述代码的thread 和 main 之间的结束顺序是不确定的如果我们希望让代码中的t先结束, main后结束, 就可以在main中使用线程等待join(join也要抛异常, 和sleep抛出的异常相同) 我们先修改一下代码, 让thread打印六次, main打印三次, 此时一定是main先结束, 再打印几次thread后, thread才结束 接下来我们加入join 注

m0_73992740的博客 1245

在子线程中创建子线程及线程查看方法

小结:我们看到,son线程的退出,并没有影响到孙线程的运行,因为进程并未退出。 以上述方式一的形式查看线程:1)同一进程中的线程是平等的,没有父子之分。当然也包括所谓的主线程、在主线程中创建的线程、在所谓的子线程中创建的线程。线程既然是平等的,只要进程不退出,倘若son线程退出,我们看到不会影响到孙线程的运行。2)孙线程在子线程中创建,可以理解为,启动孙线程的顺序点是在此时,而并非在主线程中。也就是说,我们可以在任意我们需要创建一个平行任务的地方,创建一个子线程,而并非得在主线程中创建。3)线程函数,其实,

modi000的博客 3070
上一篇: 注解Annotation
下一篇: File类
xiaobaichao_java
博客等级 码龄6年 0粉丝 39原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值