线程

最新推荐文章于 2024-11-14 14:48:14 发布
最新推荐文章于 2024-11-14 14:48:14 发布
阅读量551 收藏
点赞数
文章标签： 线程 线程同步 java

Javad   的线程是通过java.lang.Thread类来实现的
VM启动时会有一个由主方法（public static void main(){}）suo dingyi d xiancheng所定义的线程 .
可以通过创建Thread的实例来创建新的线程
每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，方法run()成为线程体。
通过调用Thread类的start()方法来启动一个线程。

创建线程的两种方法：

方法一：（good）

public class TestThread1{
	public static void main(String []args){
		Runner1 r=new Runner1();
		Thread t=new Thread(r);
		t.start();
		for(int i=0;i<100;i++){
			System.out.println("main"+i);
			}
		}
	}
	
	class Runner1 implements Runnable{
		public void run(){
			for(int i=0;i<100;i++){
				System.out.println("Runner1"+i);
				}
			}
		}


方法二：

public class TestThread2{
	public static void main(String []args){
		Runner1 r=new Runner1();
		r.start();
		
		for(int i=0;i<100;i++){
				System.out.println("main-------"+i);
		}
	}
}
	
	class Runner1 extends Thread{
		public void run(){
			for(int i=0;i<100;i++){
				System.out.println("Runner1-------"+i);
				}
			
		}
	}

线程控制基本方法:


     方法                                   功能
 
 isAlive()                      判断线程是否还活着，即线程是否还未终止
 
 getPriority()                获得线程的优先级数值
 
 setPriority()                设置线程的优先级数值
 
 Thread.sleep()          将当前线程睡眠指定毫秒数
 
 join()          调用某线程的该方法，将当前线程与该线程“合并”，即等待该线程结束，再回复当前线程的运行。
 
 yield()         让出CPU，当前线程进入就绪队列等待调度
 
 wait()          当前线程进入对象的wait pool
 
 notify()/notifyAll()     唤醒对象的wait pool中的一个/所有等待线程。

 

sleep方法

sleep()由于是静态方法，可以由类名直接调用：Thread.sleep()

sleep() Example

 

import java.util.*;
public class TestSleep{
	public static void main(String []args){
		Runner r=new Runner();
		r.start();
		
		try{
		Thread.sleep(10000);                      //这里是让主线程睡眠10秒
		                                        //sleep是静态方法，注意其使用！
	}catch(InterruptedException e){}
		r.interrupt();
		
		}
	}
	class Runner extends Thread{
		public void run(){
			while(true){
				System.out.println("---"+new Date()+"---");
				try{sleep(1000);}
				catch(InterruptedException e){
					return ;
					}
				}
			}
		
		}

 

 join方法
   合并某个线程
 yield方法
   让出CPU，给其他线程执行的机会

 

join  example

public class TestJoin{
	public static void main(String []args){
		Runner r=new Runner("mythread");
		
		r.start();
		try{r.join();
		}catch(InterruptedException e){}
			for(int i=0;i<10;i++){
				System.out.println("I am main thread");
				}
		
		}
	}
	class Runner extends Thread{
		Runner(String s){super(s);}
		public void run(){
			for(int i=1;i<10;i++){
				System.out.println("I am "+getName());
				try{
					sleep(1000);
				}catch(InterruptedException e){return;}
				}
			}
		
		}


 yield example

public class TestYield{
	public static void main(String []args){
			Mythread t1=new Mythread("abc-----");
	    Mythread t2=new Mythread("def");
	    t1.start();
	    t2.start();
		}

	
	}
	
	class Mythread extends Thread{
		Mythread(String s){super(s);}
		public void run(){
			for(int i=1;i<=100;i++){
				System.out.println(getName()+":  "+i);
				if(i%10==0)yield();
				}
			}
		}


 

线程的优先级别
   java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程。线程调度器按照线程的优先级别决定应调度哪个线程来执行。
   线程的有限级别用数字表示，范围从1到10，一个线程的缺省优先级是5.
   Thread.MIN_PRIORITY=1;
   Thread.MAX_PRIORITY=10;    (静态变量)
   Thread.NORM_PRIORITY=5;

 

example    [为什么注释起来的写法不可以呢？？？]

public class TestPriority{
	public static void main(String []args){
		/*
			Mythread t1=new Mythread("abc-----");
	    Mythread t2=new Mythread("def");
	    t1.setPriority(Thread.NORM_PRIORITY+3);
	    t1.start();
	    t2.start();
		}
		*/
		Thread t1=new Thread(new T1());
		Thread t2=new Thread(new T2());
		t1.setPriority(9);

//setPriority（）放在start（）之前！！！
   		t1.start();
		t2.start();	

	}
}
	/*
	class Mythread extends Thread{
		Mythread(String s){super(s);}
		public void run(){
			for(int i=1;i<=10;i++){
				System.out.println(getName()+":  "+i);
				
				}
			}
		}
		*/
		class T1 implements Runnable{
			public void run(){
				for(int i=0;i<100;i++)
				System.out.println("T1: "+i);
				}
			}
			
			class T2 implements Runnable{
			public void run(){
				for(int i=0;i<100;i++)
				System.out.println("T2: "+i);
				}
			}


一些小例子：

public class TestThread11{
	public static void main(String []args){
		runner r=new runner();
		Thread t1=new Thread(r);
		Thread t2=new Thread(r);
		t1.start();
		t2.start();
		}
	
	}
	class runner implements Runnable{
		public void run(){
			for(int i =0;i<30;i++){
				System.out.println("No."+i);
				}
			}
		}
 
public class TestThread22{
	public static void main(String args[]){
		Runner r=new Runner();
		Thread t=new Thread(r);
		t.start();
		}

}

class Runner implements Runnable{
	public void run(){
		for(int i=0;i<30;i++){
			if(i%10==0&&i!=0){
				try{
				
				Thread.sleep(2000);
			}catch(InterruptedException e){}
				}
				System.out.println("No."+i);
			}
		}
	}



 

public class TestThread3{
	public static void main(String []args){
		mythread r=new mythread();
		Thread t=new Thread(r);
		t.start();
		for(int i=0;i<100;i++){
			System.out.println("--------------main:  "+i);
		}
		System.out.println("thread main is over!  ");
		r.shutdown();                                    //此处不是t.shutdown()  !!!!
	}
}
	
	
	class mythread implements Runnable{
		private boolean flag=true;
		public void run(){
			int i=0;
			while(flag){
				System.out.println("mythread:  "+i++);
				}
		}
		
		public void shutdown(){
			flag=false;
			
			}
	}


public  class TestThread4{
	public static void main(String []args){
		Thread t=new Thread(new mythread());
		t.start();
		for(int i=0;i<30;i++){
				System.out.println("----------MainThread:"+i);
		}
	}
}
	class mythread implements Runnable{
		public void run(){
			System.out.println(Thread.currentThread().isAlive());
			for(int i=0;i<30;i++){
				System.out.println("SubThread:"+i);
				}
			}
		}

 

线程同步
 

线程同步

public class TestSync implements Runnable{
	Timer timer=new Timer();
	public static void main(String []args){
		TestSync test=new TestSync();
		Thread t1=new Thread(test);
		Thread t2=new Thread(test);
		t1.setName("t1");
		t2.setName("t2");
		t1.start();
		t2.start();
		}
		public void run(){
			timer.add(Thread.currentThread().getName());
			}
	
	}
	class Timer{
		private static int num;
		public synchronized void add(String name){
//			synchronized(this){
			num++;
			try{
			Thread.sleep(1);
		}catch(InterruptedException e){}
			System.out.println(name+",你是第"+num+"个使用timer的线程");
//			}
			}
		}


 

死锁

 

public class TestDeadLock implements Runnable{
	private int flag=1;
	static Object o1=new Object();
	static Object o2=new Object();
	public void run(){
		System.out.println("flag="+flag);
		if(flag==1){
			synchronized(o1){
				try{
					Thread.sleep(500);
				}catch(Exception e){}
			
			synchronized(o2){
				System.out.println(1);
				}
		}
	}
	
	
	if(flag==0){
			synchronized(o2){
				try{
					Thread.sleep(500);
				}catch(Exception e){}
			
			synchronized(o1){
				System.out.println(0);
				}
		}
	}
}
	public static void main(String []args){
		TestDeadLock td1=new TestDeadLock();
		TestDeadLock td2=new TestDeadLock();
		td1.flag=1;
		td2.flag=0;
		Thread t1=new Thread(td1);
		Thread t2=new Thread(td2);
		t1.start();
		t2.start();
		}
}


 

注意：在下面的程序中，m1方法加了锁，在m1方法执行期间，由于m2方法没有加锁，所以另外的线程可以去执行m2方法！只有当m2方法也加了锁后，另外的线程必须等原先线程执行完m1后才能执行m2！

 


 

public class TT implements Runnable{
	int b=100;
	public synchronized void m1() throws Exception{
		b=1000;
		Thread.sleep(5000);
		System.out.println("b="+b);
		
		}
		
		public  (synchronized)  void m2(){
			System.out.println(b);
		}
		public void run(){
				try{
					m1();
				}catch(Exception e){}
		}
		
		public static void main(String []args) throws Exception{
			TT tt=new TT();
			Thread t=new Thread(tt);
			t.start();
			Thread.sleep(1000);
			tt.m2();
			}
}


程序执行结果：   当public    void m2(){。。。}时：

                            1000

                            b=1000

                            当public  synchronized  void m2(){。。。}时：

                            b=1000

                           1000

 

example,      针对下面两张情况的结果

public class TT implements Runnable{
	int b=100;
	public synchronized void m1() throws Exception{
		b=1000;
		Thread.sleep(5000);
		System.out.println("b="+b);
		
		}
		
		public (synchronized) void m2()throws Exception{
			Thread.sleep(2500);
			b=2000;
		}
		public void run(){
				try{
					m1();
				}catch(Exception e){}
		}
		
		public static void main(String []args) throws Exception{
			TT tt=new TT();
			Thread t=new Thread(tt);
			t.start();
			Thread.sleep(1000);
			tt.m2();
			System.out.println(tt.b);
			}
}

 

 

生产者和消费者问题：

 

 

 

 

 

 

 

 

 

 

 


   wait 和sleep区别：
   wait时别的线程可以访问锁定对象，调用wait方法时必须锁定该对象
   sleep时别的线程也不可以访问锁定对象


 

gchichafengyun
关注
专栏目录
Java来看一道多线程面试题
qq_40850266的博客
02-23 117
问题：下面线程开启后会执行哪一句话会输出到控制台？ 答：你好Thread 会被打印 public static void main(String[] args) { Runnable runnable = new Runnable() { @Override public void run() { System.out.println("你好Runable"); } };
【Java基础】简说多线程（上）
阿杰
04-26 385
进程是一个静态的概念，线程是一个进程里面不同的执行路径。一个CPU只能支持一个线程，真正的多线程是2个CPU以上。 基本概念 举例说明 进程，打开任务管理器，下图的一个个程序就是进程 进程再进一步，比如360卫士，一边杀毒一边体检就是两个线程 概念 线程是一个程序内部的顺序控制流 Java的线程是通过java.lang.Thread类来实现的。 VM启动时会有一个由主方法(public vo...
多线程的几个小程序，诠释多线程的基本概念
哈哈__哈哈的专栏
01-05 138
通过实现Runnable来实现多线程： [code="java"]public class TestThread1{ public static void main(String[] args){ Runner1 r = new Runner1(); Thread t = new Thread(r); t.start(); //注意：t.run(); 是指方法调用，先执行...
【多线程】线程池
王佑辉的博客
04-04 5996
3.keepAliveTime：多余的空闲线程的存活时间，当前线程池数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余空闲线程会被销毁直到只剩下corePoolSize个线程为止。7.handler：拒绝策略，表示当队列满了并且工作线程-大于等于线程池的数量最大线程数（maxinumPoolSize）时如何来拒绝请求执行的runnable的策略。6.threadFactory：表示生成线程池中工作线程的线程工厂，用于创建线程一般用默认的即可。
Qt 线程
qq_45303986的博客
02-20 6820
QThread(线程)，代表一个在应用程序中可以独立控制的线程，可以和进程中的其他线程分享数据。QThread 对象管理程序中的一个控制线程。QThreads 在 run（） 中开始执行。默认情况下，run（） 通过调用 exec（） 来启动事件循环，并在线程内运行 Qt 事件循环。
【JavaEE】线程安全性问题，线程不安全是怎么产生的，该如何应对
热门推荐
yican2580的博客
08-23 1万+
本章分析了在Java多线程编程中产生线程不安全的原因，将每一个原因举例子并分析解决方法。了解死锁产生的原因，分析如何避免死锁的发生。
【Java】了解线程 Thread 类的使用，如何创建、终止、等待一个线程以及获取线程的状态
yican2580的博客
08-21 3570
了解线程 Thread 类的使用，如何创建、终止、等待一个线程。
Java线程
m0_56188609的博客
02-22 3007
两个线程同时运行均要使用CPU，While(ture)为死循环，两个线程均需要不断使用CPU，而两个线程大量使用CPU会造成CPU占用率达到100%，其他代码、操作系统其他程序就会暂停卡住。因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码（从使用CPU到不适用CPU称之为线程的一次上下文切换）当然它的底层是否由多个核心对这两个线程并行执行还是一个核心对它们并发处理，包括打印的前后顺序是不由我们控制的。（快照：只能查看某一刻） 查看某个 Java 进程（PID）的所有线程状态。
多线程 join 方法
Gonelin的博客
12-22 6343
多线程 join 方法 1.前言 本节对 join 方法进行深入的剖析，主要内容点如下： 了解 join 方法的作用，初步的理解 join 方法的使用带来的效果是学习本节内容的基础； 了解 join 方法异常处理，我们在使用 join 方法是，需要对 join 方法进行有效的异常处理； 通过匿名内部类创建Thread 是我们本节代码示例所使用的的方式，对这种方式的掌握在后续工作中非常重要； 掌握 join 方法如何使用，这是本节的重点内容，也是本节的核心内容； 掌握带参数的 join 方法使用，在后续开发
解析Python中获取当前线程名字的方法及多线程编程实践
一键难忘的博客
04-27 2763
在多线程编程中，了解当前线程的名字是一项重要的任务。Python 提供了内置的线程模块 `threading`，通过它我们可以轻松地获取当前线程的名字。本文将介绍如何在 Python 中获取当前线程的名字，并探讨一些相关的背景知识。
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 277
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
Servlet的生命周期
wyk的博客
11-13 984
Servlet 的生命周期包含四个主要阶段：加载与实例化、初始化、请求处理、销毁。开发者可以在这些生命周期方法中编写初始化、请求处理和资源清理的代码，确保 Web 应用程序的正常运行。
Java基础07
m0_74977981的博客
11-11 678
如图下图：每个case中都有一个break，如果没有这个break，就不会跳出case，直到遇见break为止。
刷题---顺序表算法题
weixin_63997543的博客
11-11 435
顺序算法题----力扣刷题
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 720
Rest请求处理
java加锁问题详解
最新发布
qq_74056922的博客
11-14 416
java(JVAM)对加锁的API进行了封装,通过使用synchronized关键字来完成加锁操作。
Java线程优先级详解
"Java线程的优先级管理是多线程编程中的一个重要概念，它涉及到线程调度和执行的顺序。在Java中，线程的优先级被用来影响线程被操作系统选择执行的概率，但并不保证高优先级的线程一定会先于低优先级的线程执行。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值