2020/08/27 QQ1017871939 初识线程

最新推荐文章于 2023-04-12 14:56:41 发布
最新推荐文章于 2023-04-12 14:56:41 发布
阅读量492 收藏
点赞数
分类专栏： 线程 小白 自定义线程 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ok1017871939/article/details/108268203
版权
小白 同时被 3 个专栏收录
13 篇文章 0 订阅
订阅专栏
线程
1 篇文章 0 订阅
订阅专栏
自定义线程
1 篇文章 0 订阅
订阅专栏

在这里插入图片描述

初始线程

在这里插入图片描述

package com.xiancheng.ch01;

public class ThreadTest01 {

	 public static void main(String[] args) throws InterruptedException {
		//获得当前线程
		Thread t1 = Thread.currentThread();
		System.out.println("Threadname："+t1.getName());
		//获得ID
		System.out.println("ThreadID："+t1.getId());
		//获取优先级
		System.out.println("Thread优先级："+t1.getPriority());
	
	    //Thread.sleep(1000);//参数的单位是毫秒
	 for (int i = 1; i <=10; i++) {
		System.out.println(i);
		 Thread.sleep(1000);
	}
	 System.out.println("我睡眠了");
	 }
}

方法不运用线程的时候，程序像一根筋一样的走

在这里插入图片描述

package com.xiancheng.ch01;
/*
 * 开发线程的一个类，首先要求继承java.lang.Threa
 * 重写其中的run()方法
 */
//方法不运用线程就会变成整体就变成单一线程，先执行方法，等方法执行完告诉mian.main才执行
public class ThreadTest7  {
	  public void run() {
		  for (int i = 1; i <=10; i++) {
			  //currentThread()当前线程
				System.out.println("run:"+i);
			
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
	  }
	  public static void main(String[] args) throws InterruptedException {		  
		  ThreadTest7 tt2 =new ThreadTest7();
		  tt2.run(); 
		  for (int i = 1; i <=10; i++) {
				System.out.println("main"+i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		  
	}
}

方法运用线程的时候，嘿，好兄弟我们一起走

在这里插入图片描述

package com.xiancheng.ch01;
/*
 * 开发线程的一个类，首先要求继承java.lang.Threa
 * 重写其中的run()方法
 */
//运用了线程，main方法就可以和线程一起执行，不用等到线程执行完毕结束main方法才接下来运行
public class ThreadTest6 extends Thread {
	//父类没有抛异常，子类不能抛异常，这次只能捕获
	  @Override
	    public void run() {
		  for (int i = 1; i <=10; i++) {
				System.out.println(Thread.currentThread().getName()+":"+i);
			
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
	  }
	  public static void main(String[] args) throws InterruptedException {		  
		  ThreadTest6 tt2 =new ThreadTest6();
		 //join合并得在start之后
		  tt2.start();
//		  new Thread(tt2).start();
//		  new Thread(tt2).start();
		  for (int i = 1; i <=10; i++) {
			  //当main方法读到这句话的时候，告诉tt2我们合并在一起
			  //这时候合并线程，将tt2线程合并到了main线程，变成了一个线程
//			    tt2.join();
				System.out.println("main"+i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		  
	}
}

可以看出main老板调用线程的时候我是执行我线程方法，main老板懒得理我完成怎样了。这也不难举个例子，比如你QQ开空间的时候加载空间里面的内容和你点QQ头像聊天，你聊天的时候非得等你空间加载完成告诉我空间加载完成了吗？没必要，你加载你的空间，我聊我的天。别耽误我们的时间，其实线程也不难看出是统筹简算的成果。

在这里插入图片描述
在这里插入图片描述

package com.xiancheng.ch01;

public class ThreadTest01 {

	 public static void main(String[] args) throws InterruptedException {
		//获得当前线程
		Thread t1 = Thread.currentThread();
		System.out.println("Threadname："+t1.getName());
		//获得ID
		System.out.println("ThreadID："+t1.getId());
		//获取优先级
		System.out.println("Thread优先级："+t1.getPriority());
	
	    //Thread.sleep(1000);//参数的单位是毫秒
	 for (int i = 1; i <=10; i++) {
		System.out.println(i);
		 Thread.sleep(1000);
	}
	 System.out.println("我睡眠了");
	 }
}

在这里插入图片描述

第一种继承Thread类

在这里插入图片描述

package com.xiancheng.ch01;
/*
 * 开发线程的一个类，首先要求继承java.lang.Threa
 * 重写其中的run()方法
 */
//运用了线程，main方法就可以和线程一起执行，不用等到线程执行完毕结束main方法才接下来运行
public class ThreadTest6 extends Thread {
	//父类没有抛异常，子类不能抛异常，这次只能捕获
	  @Override
	    public void run() {
		  for (int i = 1; i <=10; i++) {
			  //currentThread()当前线程
				System.out.println(Thread.currentThread().getName()+":"+i);
			
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
	  }
	  public static void main(String[] args) throws InterruptedException {		  
		  ThreadTest6 tt2 =new ThreadTest6();
		  //如果你写成tt2.run()是启动线程执行run方法
		  //而不是启动线程，启动线程用tt2.start
		  tt2.start();
		  for (int i = 1; i <=10; i++) {
				System.out.println("main"+i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		  
	}
}

多次调用线程的方法一

在这里插入图片描述

多次调用线程的方法二

在这里插入图片描述

第二种 实现Runnable接口

在这里插入图片描述

package com.xiancheng.ch01;
/*
 * 线程的实现 方式二
 * 实现runnable接口，实现其中run（）方法
 * 如何启动这个线程？
 */
public class ThreadTest8 implements Runnable {
	@Override
	public void run() {
		 for (int i = 1; i <=10; i++) {
				System.out.println("run:"+i);
				 try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
			}
	}

public static void main(String[] args) {
	 
	 ThreadTest8 tt3 =new ThreadTest8();
	 new Thread(tt3).start();
		for(int i=1;i<=10;i++) {
			
			System.out.println("main : "+i);
			
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
}
}

Runable接口多次调用线程方法

在这里插入图片描述
在这里插入图片描述

拓展补充线程创建的另外两种方法

方法一：实现Callable接口

在这里插入图片描述
在这里插入图片描述

代码

package com.UserMangertest01;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/*
 * JDK5.0新增的线程的实现方式：
 * 实现方式三：
 *  > 实现这个接口：Callable，实现call方法
 *  > 创建FutureTask实例，通过线程实现类构造完成的
 *  > 通过Thread类的实例来启动线程
 *  > 通过 task.get();获取返回值
 *  
 */
public class ThreadTest111 implements Callable {

	int sum =0;
	@Override
	public Object call() throws Exception {
		//完成1-100累加和
		for (int i = 1; i <=100; i++) {
			sum+=i;
			System.out.println("sum:"+sum);
		     Thread.sleep(20);
		}
		return sum;
	}
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		
		ThreadTest111 tt1 =new ThreadTest111();
		//没有直接调用的方法，这里得先创建一个未来的任务
		FutureTask task =new FutureTask(tt1);
		//再去执行未来任务里面的内容
		new Thread(task).start();
		//不过能获取返回值
		Object str =task.get();
		System.out.println(str);
		//总结，我觉得Callable接口实现线程步骤挺复杂的，不过它有renturn返回值这一功能，怎么说有的也有失吧
	}

}

方法二 ：线程池方法

在这里插入图片描述

newFixedThreadPool() 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

在这里插入图片描述

代码

package com.UserMangertest01;

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

public class ExcutorTest1 {
   public static void main(String[] args) {
	//线程池的演示
	  ExecutorService threadPool =  Executors.newFixedThreadPool(100);
	  //for循环是为了创造多对线程，轻松快速
      for (int i = 0; i < 30; i++) {
	  threadPool.execute(new MyThread101() );
      threadPool.execute(new MyThread102() );		
	}
	  
//      threadPool.execute(new MyThread101() );
//      threadPool.execute(new MyThread102() );
      //用完记得关闭线程池
      threadPool.shutdown();
   //总结，虽然线程池的名字很长，但是我感觉真的很好用
   }
}

class MyThread101 implements Runnable{

	@Override
	public void run() {
          for (int i = 0; i < 100; i++) {
			if(i%2==0) {
				System.out.println(Thread.currentThread().getName()+"---->"+i);
			try {
				Thread.sleep(20);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			}
		}		
	}
	
}

class MyThread102 implements Runnable{

	@Override
	public void run() {
          for (int i = 0; i < 100; i++) {
			if(i%2!=0) {
				System.out.println(Thread.currentThread().getName()+"---->"+i);
			try {
				Thread.sleep(20);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			}
		}		
	}
	
}

在这里插入图片描述

中断线程的操作

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

package com.xiancheng.ch01;
/*
 * 线程的实现 方式二
 * 实现runnable接口，实现其中run（）方法
 * 如何启动这个线程？
 */
public class ThreadTest8 implements Runnable {
	//每个线程都有flag，标志着中断位
	/*
	 * 因为服务或线程不能被立即停止，立即停止会使共享的数据结构不一致，相反，应该在停止前做一些清理工作，然后再结束。
	 * 所以说，不能你让我停我就停，我自己执行的任务，我比你更能清楚在停止前如何进行清理工作。
	 * 因此，最终的设计就变成了：线程main给tt3发interrupt信号，B收到信号后，自己决定先做些什么，然后再退出。
	 * 这是一种协作机制，需要tt3配合。
	 */
	private boolean flag; //默认为false没有定义的时候
	
	public boolean isFlag() {
		return flag;
	}

	public void setFlag(boolean flag) {
		this.flag = flag;
	}

	@Override
	public void run() {
		 for (int i = 1; i <=10; i++) {
				System.out.println("run:"+i);
				 try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				 if(flag) {
					 //tt3检查自己的interrupt状态为true，并自愿地退出线程，是Java中唯一的一个线程让另一个线程终止的方法！
					 return;
				 }
//				 if(i==5) {
//					 //当i==5的时候终止线程的演示 //不是最佳选择
//					 Thread.currentThread().interrupt();//java.lang.InterruptedException
//				 }
				
			}
	}

public static void main(String[] args) {
	 
	 ThreadTest8 tt3 =new ThreadTest8();
	 new Thread(tt3).start();

		for(int i=1;i<=10;i++) {
			
			System.out.println("main : "+i);
			
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			if(i==5) {
				//如果main方法想让tt3这个线程结束，就把这个中断位flag设为true
				//终止tt3这个线程
				tt3.setFlag(true);
			}
		}
}
}

在这里插入图片描述

方法一

在这里插入图片描述

package com.xiancheng.ch01;

public class ThreadTest9 {

	 public static void main(String[] args) {
		 Nunoushu p1 =new Nunoushu();
		 Nunjishu p2 =new Nunjishu();
		 
		 p1.start();
		 
		 p2.start();
	}
}

class Nunoushu extends Thread {
	
	public void run() {
		for (int i = 1; i <= 100; i++) {
			if(i % 2 == 0) {
				System.out.println(this.getName()+" --> "+i);
			}
			try {
				sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

class Nunjishu extends Thread {
	
	public void run() {
		for (int i = 1; i <= 100; i++) {
			if(i % 2 != 0) {
				System.out.println(this.getName()+" --> "+i);
			}
		  try {
			sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		}
	}
}

方法二（用匿名类）
在这里插入图片描述

package com.xiancheng.ch01;

public class ThreadTest10 {

	public static void main(String[] args) {
		
		//匿名类的奇数
		new Thread() {
			public void run() {
				for (int i = 1; i <= 100; i++) {
					if(i % 2 != 0) {
						System.out.println(this.getName()+" --> "+i);
					}
					try {
						sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}.start();
		
		//匿名类的偶数
		new Thread() {
			public void run() {
				for (int i = 1; i <= 100; i++) {
					if(i % 2 == 0) {
						System.out.println(this.getName()+" --> "+i);
					}
					try {
						sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}.start();
	}
}

有的人觉得输出名字很丑在控制台上 可以修改名字

方法一

在这里插入图片描述

方法二

在这里插入图片描述

方法三

调用父类String的方法

在这里插入图片描述

代码

package com.xiancheng.ch01;

public class ThreadTest9 {

	 public static void main(String[] args) {
		 Nunoushu p1 =new Nunoushu("偶数");
		 Nunjishu p2 =new Nunjishu("奇数");
		 p1.start();
//方法一	 
//		 p1.setName("偶数");
//		 p2.setName("奇数");
		 p2.start();
	}
}

class Nunoushu extends Thread {
	
//方法二  在每一个自己的类里面构造

	public Nunoushu(String name) {
		//方法三
		//因为父类中存在有
		//   public Thread(String name) 
		//可以重写父类的构造方法
		super(name);
	}
	

	public void run() {
		for (int i = 1; i <= 100; i++) {
			if(i % 2 == 0) {
				//当super父类的时候，所用的方法是父类，
				//父类里面有 public final synchronized void setName(String name) 
				System.out.println(this.getName()+" --> "+i);
			}
			try {
				sleep(1000);
			} catch (InterruptedException e) {
			
				e.printStackTrace();
			}
		}
	}
}

class Nunjishu extends Thread {
	
//方法三  继承父类的构造方法改写
	public Nunjishu(String name) {
		super(name);
	}

	public void run() {
		for (int i = 1; i <= 100; i++) {
			if(i % 2 != 0) {
				System.out.println(this.getName()+" --> "+i);
			}
		  try {
			sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		}
	}
}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

package com.xiancheng.ch01;

public class ThreadTest9 {

	 public static void main(String[] args) {
		 Nunoushu p1 =new Nunoushu("偶数");
		 Nunjishu p2 =new Nunjishu("奇数");
		 p1.setPriority(Thread.MAX_PRIORITY);
		 p1.start();
		 System.out.println("-------------------->>>>> "+p1.isAlive());
	    	//设置优先级必须在启动前面，不能给负数或者给小于最小优先级  不然会报错。


		 p2.setPriority(Thread.MIN_PRIORITY);
		 p2.start();
		 
		 System.out.println("-------------------->>>>> "+p2.isAlive());
	}
}

class Nunoushu extends Thread {
	
	public Nunoushu(String name) {
		super(name);
	}
	

	public void run() {
		for (int i = 1; i <= 100; i++) {
			if(i % 2 == 0) {
				System.out.println(this.getName()+" --> "+i);
			}
			
		}
	}
	
}

class Nunjishu extends Thread {

	public Nunjishu(String name) {
		super(name);
	}

	public void run() {
		for (int i = 1; i <= 100; i++) {
			if(i % 2 != 0) {
				System.out.println(this.getName()+" --> "+i);
			}
		
		}
	}
}
五菱开发工程师
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
QT 初识线程(简单实现)
断点
11-25 2351
QT多线程专栏共有14篇文章，从初识线程到、QMutex锁、QSemaphore信号量、Emit、Sgnals、Slot主线程子线程互相传值同步变量、QWaitCondition、事件循环、QObjects、线程安全、线程同步、线程异步、QThreadPool线程池等线程操作进行了全面！深入！的研究和详细的说明
labwindows/CVI 线程锁的基本使用方法
最新发布
02-21
其大致设计思路为根据各个控件对应的回调函数来完成特定的任务，但是由于各个回调函数都在一个线程里进行响应，这就意味着当一个回调函数在进行的时候，其他回调函数是无法响应的。可以通过在回调函数中开辟新线程的...
ch01 Python基本语法元素
qq_46173177的博客
08-20 204
第一章 Python基本语法元素 1.1 程序设计基本方法 根据执行方式不同，编程语言分为两类。 静态语言：使用编译执行的编程语言，如C/C++语言、Java语言。 编译器一次性生成目标代码，之后不再需要源代码。 脚本语言：使用解释执行的编程语言，如Python语言、JavaScript语言、PHP语言。 执行程序时需要源代码，运行时随翻译随执行。 IPO：程序的基本编写方法 I：Input输入；P：Process处理；O：Output输出。 1.2 Python开发环境 Python基本开发环境IDLE
【多线程】初识多线程
程序猿教你打篮球的博客
04-12 5001
本期主要讲解： 1.为什么要学习多线程? 2.进程的认识 2.1进程与线程的关系 2.2进程间如何通信? 3.计算机如何描述进程的? 3.1概述 3.2 PCB是如何描述进程的? 4.线程的调度 5.线程的缺点
java并发编程之初识线程
FOREVER_DO
08-07 745
java并发编程之初识线程说明线程生命周期线程创建线程间通信线程池生产者消费者实例 说明 操作系统运行一个程序就会创建一个进程，例如我们一个main函数程序启动了，就会创建一个java进程，然后有一个main主线程和其他线程（至少一个垃圾回收线程），这时我们如果想java做的任务更多时间更少就可以创建更多线程，这样能够最大化利用cpu,更快响应。 线程生命周期 线程创建 线程间通信 线程池 生产...
Java企业QQ/文件传输/表情
02-24
在Java编程领域，企业QQ和文件传输功能是常见的应用场景，特别是在企业级的通讯系统中。这个项目显然关注的是如何利用Java实现这样的功能，同时结合了网络编程和多线程技术。下面将详细讨论这些关键知识点。 首先，...
QQ多线程批量查冻结源码易语言源码
04-04
总的来说，QQ多线程批量查冻结源码利用易语言和多线程技术实现了高效且便捷的QQ账号状态检测，而提供的相关模块和文件则有助于开发者更好地理解和利用这个工具。对于想学习易语言编程、多线程处理以及网络请求的人来...
QQ.zip_ICQ/即时通讯_Java_
08-11
综上所述，QQ.zip中的Java即时通讯系统涵盖了网络编程、多线程、数据传输、并发控制、用户界面设计等多个关键领域，为学习和实践这些技能提供了一个实际项目背景。通过分析和改进这个项目，开发者可以深入理解如何在...
JAVA多线程类QQ简单实现
12-28
在本项目中，“JAVA多线程类QQ简单实现”是一个基于客户端-服务器架构的QQ聊天应用的简化版本，它利用了JAVA编程语言的核心特性——多线程，来处理并发的网络通信。王刚老师的“疯狂JAVA”系列教程是这个项目的灵感...
Linux动态启用/禁用超线程技术的方法详解
09-14
在Linux系统中，超线程技术（Hyper-Threading，简称HT）是一种先进的处理器功能，它允许单个物理核心同时处理两个线程，从而提高处理器的效率和系统性能。特别是当系统执行多任务或运行轻量级任务时，超线程技术能够...
vue echarts(2020/10/22更新)
10-22
echarts作为vue组件进行使用，可实现一个页面加载多个echarts实例，互不冲突。页面大小变动自适应。文章链接：https://blog.csdn.net/qq_35134375/article/details/109164031
C# QQ源码 C/S结构
05-14
本用于政务网的即时通信的政务交流工具，界面上高仿QQ，包含完整客户端、服务器端、数据库源文件，全部C#编写，数据库采用SQL SERVER2008。系统采用TCP直连和服务器转发的综合设计，能穿透防火墙和不在线留言功能...
QQ_java多线程_
10-04
本项目"QQ_java多线程_"聚焦于利用Java的多线程特性实现一个类似QQ的通信系统，涵盖客户端和服务端的交互。 在Java中，多线程的创建主要有两种方式：通过继承`Thread`类和实现`Runnable`接口。在这个项目中，服务端...
QQ.rar_ICQ/即时通讯_Visual_C++_
08-11
标题中的“QQ.rar”指的是一个使用RAR压缩格式的文件，其中可能包含了QQ的源代码或者相关的开发资源。这个文件特别提到了“ICQ/即时通讯”，这意味着它与即时通信软件有关，尤其是ICQ和QQ这两种知名的聊天应用。即时...
vbqq.rar_ICQ/即时通讯_Visual_Basic_
08-12
【标题】"vbqq.rar" 是一个使用Visual Basic编写的模仿QQ聊天软件的源代码压缩包，它展示了如何利用Visual Basic这一编程语言实现即时通讯功能，就如同ICQ或QQ这样的在线聊天工具。这个项目对于想要学习如何构建类似...
Qt 实现（基于tcp/ip）类似QQ聊天
12-26
用Qt简单的实现了QQ聊天的功能，基于tcp/ip协议的
C++编写的多线程C/S模式仿QQ软件
01-15
《C++实现的多线程C/S模式仿QQ软件详解》 C++作为一种强大的编程语言，广泛应用于系统开发、游戏引擎、服务器等多个领域。在本文中，我们将深入探讨如何使用C++来构建一个多线程的客户端/服务器（C/S）模式的仿QQ...
停止线程和取消线程任务的案例代码
01-28
包含了停止线程和取消线程任务的案例代码，介绍了四五种停止线程、取消线程任务的方式，有Thread.stop()、Thread.interrupt()、future,cancel(true)等等，也可以查看文章【https://blog.csdn.net/qq_39826207...
https://weread.qq.com/
06-01
https://weread.qq.com/ 是腾讯推出的一个阅读平台，用户可以在该平台上阅读各类图书、小说、杂志和漫画等。该平台提供了多种阅读方式和社交分享功能，用户可以通过该平台分享自己的阅读心得和评论，并与其他用户...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值