`
duolaaqian
  • 浏览: 14302 次
  • 性别: Icon_minigender_1
  • 来自: 天津
社区版块
存档分类
最新评论

[初级]线程

    博客分类：
  • java
初级java线程 
阅读更多
  • 创建线程三种方法：
/**
 * 线程创建方法1：创建线程类
 * 	1、创建线程类，继承Thread并重写 run() 方法
 * 	2、创建对象实例，调用对象 start() 方法来启动线程
 */
public class CreateTest1 {
	public static void main(String[] args) {
		Rabbit rab = new Rabbit();
		Tortoise tor = new Tortoise();
		rab.start();
		tor.start();
		for(int i=0;i<1000;i++){
			System.out.println("main==>"+i);
		}
	}
}

class Rabbit extends Thread{
	@Override
	public void run(){
		for(int i=0;i<50;i++){
			System.out.println("兔子跑了 "+i+" 步");
		}
	}
}
class Tortoise extends Thread{
	@Override
	public void run(){
		for(int i=0;i<50;i++){
			System.out.println("乌龟跑了 "+i+" 步");
		}
	}
}

 

/**
 * 线程创建方法2：继承Runnable接口
 * 	1、创建类并继承Runnable接口，重写 run() 方法
 * 	2、通过 Thread 生成代理类
 * 	3、调用代理类的 start() 方法启动线程
 */
public class CreateTest2 {
	public static void main(String[] args) {
		Work1 w1 = new Work1();
		Work2 w2 = new Work2();
		
		Thread t1 = new Thread(w1);
		Thread t2 = new Thread(w2);
		
		t1.start();
		t2.start();
		
		for(int i=0;i<1000;i++){
			System.out.println("main....");
		}
	}
}

class Work1 implements Runnable{
	@Override
	public void run() {
		for(int i=0;i<1000;i++){
			System.out.println("一边聊QQ....");
		}
	}
}
class Work2 implements Runnable{
	@Override
	public void run() {
		for(int i=0;i<1000;i++){
			System.out.println("一边敲hello world....");
		}
	}
}

 

/**
 * 线程创建方法3：匿名内部类
 * 	1、创建 Thread 类并重写 run() 方法
 * 	3、调用 start() 方法启动线程
 */
public class CreateTest3 {
	public static void main(String[] args) {
		Thread t1 = new Thread(){
			@Override
			public void run() {
				for(int i=0;i<1000;i++){
					System.out.println("匿名....");
				}
			}
		};
		t1.start();
		for(int i=0;i<1000;i++){
			System.out.println("main....");
		}
	}
}

 

推荐使用继承 Runnable 方法创建线程

/**
 * 推荐使用继承 Runnable 方法创建线程
 * 	1、避免单继承局限性
 * 	2、便于共享资源
 * 
 * 	模仿买票，票为共享资源，多线程操作同一资源
 */
public class CreateTest4 {
	public static void main(String[] args) {
		Web12306 web = new Web12306();
		
		Thread t1 = new Thread(web,"路人甲");
		Thread t2 = new Thread(web,"黄牛乙");
		Thread t3 = new Thread(web,"工程狮");
		
		t1.start();
		t2.start();
		t3.start();
	}
}

class Web12306 implements Runnable{
	private int num = 50;
	
	@Override
	public void run() {
		while(true){
			if(num<=0){
				break;
			}
			System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
		}
	}
}

 

 

  • 线程状态方法
/**
 * 线程阻塞
 * 	t1.join();
 * 阻塞本线程，t1执行完后再执行本线程
 * 相当于将本线程追加到t1后(合并线程)
 */
public class JoinDemo01 extends Thread{
	public static void main(String arg[]) throws InterruptedException{
		JoinDemo01 demo1 = new JoinDemo01("t1");
		JoinDemo01 demo2 = new JoinDemo01("t2");
		Thread t1 = new Thread(demo1);
		Thread t2 = new Thread(demo2);
		
		t1.start();
		t2.start();
		for(int i=0;i<1000;i++){
			if(100==i){
				t1.join();//main阻塞，t执行完后main再执行(阻塞当前线程，并将当前线程追加到t1后)
			}
			System.out.println("main"+i+" .... ");
		}
	}
	
	private String name;
	public JoinDemo01(String name){
		this.name = name;
	}
	
	@Override
	public void run() {
		for(int i=0;i<2000;i++){
			System.out.println("["+name+"]"+i+" .... .... ");
		}
	}
}

 

/**
 * 线程等待
 * 	Thread.sleep(1000);
 * 该线程进入等待状态，不释放锁，小心死锁
 */
public class SleepDemo01 {
	public static void main(String[] args) throws InterruptedException {
		Date d1 = new Date();
		System.out.println(new SimpleDateFormat("mm:ss SS").format(d1));
		Thread.sleep(1000);
		d1 = new Date();
		System.out.println(new SimpleDateFormat("mm:ss SS").format(d1));
	}
}
  
/**
 * 线程暂停
 * 	Thread.yield();
 * 暂停本线程，但是并不确保一定会运行其他线程
 * 如果cpu再次调度到本线程则会继续执行本线程
 */
public class YieldDemo01 extends Thread{
	public static void main(String[] args) {
		YieldDemo01 y1 = new YieldDemo01();
		Thread t1 = new Thread(y1);
		t1.start();
		
		for(int i=0;i<100;i++){
			System.out.println("main...."+i+"["+i%20+"]");
			if(i%20==0){
				System.out.println("y");
				Thread.yield();//暂停本线程 main
			}
		}
		
	}
	
	@Override
	public void run() {
		for(int i=0;i<1000;i++){
			try {
				Thread.sleep(0, 1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("yield...."+i);
		}
	}
}

 

 

  •  线程同步
/**
 * 线程同步(安全、效率低)
 * synchronized关键字主要是锁定资源
 * synchronized关键字修饰的资源有线程访问，则该资源对于其他线程的状态就为锁定状态
 * 该线程执行完synchronized修饰的代码块后，该资源解除锁定状态
 * 其他线程如果访问被锁定的资源，则会等待，等待该资源解除锁定状态
 */
public class SynDemo01 {
	public static void main(String[] args) {
		MyJvm mj = new MyJvm();
		Thread t1 = new Thread(mj,"张三");
		Thread t2 = new Thread(mj,"老王");
		
		t1.start();
		t2.start();
	}
}

class MyJvm implements Runnable{
	@Override
	public void run() {
		synchronized(MyJvm.class){
			for(int i=0;i<1;i++){
				System.out.println(Thread.currentThread().getName()+" 线程执行开始 ");	
			}
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			for(int i=0;i<1;i++){
				System.out.println(Thread.currentThread().getName()+" 线程执行结束 ");	
			}
		}
	}
}

 

 

  •  线程属性
/**
 * 线程中的属性
 * 	Thread.currentThread() --> 当前线程
 * 	setName()/getName() --> 设置/获取 线程名称(默认为'Thread-'+线程个数)
 * 	isAlive() --> 判断线程状态是否处于活动状态
 * 
 * 	setPriority() --> 设置线程优先级
 * 		该优先级只是概率，并不是绝对优先级
 * 		MAX_PRIORITY  10
 * 		NORM_PRIORITY 5 (默认)
 * 		MIN_PRIORITY  1
 */
public class InfoDemo01 {
	public static void main(String[] args) throws InterruptedException {
		InfoThread it = new InfoThread();
		Thread t = new Thread(it,"挨踢");
		t.setPriority(Thread.MAX_PRIORITY);
		
		t.start();
		System.out.println("启动后的状态:"+t.isAlive());
		Thread.sleep(1000);
		it.stop();
		Thread.sleep(1000);
		System.out.println("停止后的状态:"+t.isAlive());
	}

}

class InfoThread implements Runnable{
	private boolean flag = true;
	private int num =0;
	@Override
	public void run() {
		while(flag){
			System.out.println(Thread.currentThread().getName()+" --> "+num++);
		}
	}
	public void stop(){
		this.flag = false;
	}
}
 
 
  • 定时器
/**
 * 定时执行线程
 * 	1、创建定时器和定时任务(Timer、TimerTask)
 * 	2、将定时任务添加到定时器中并启动定时器
 * 	3、任务执行完以后，如不需要应终止定时器
 * 
 * 	Timer.schedule(TimerTask,Date,long)
 * 	执行任务，在 Date 时间点执行 TimerTask 任务 ，每隔 long 执行一次(可选)
 */
public class ScheduleDemo01 {
	public static void main(String[] args) {
		Timer timer = new Timer();
		TimerTask task = new TimerTask(){
			@Override
			public void run() {
				System.out.println("任务执行开始....");
				try {
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("任务执行结束....");
			}
		};
		timer.schedule(task,new Date());
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		timer.cancel();
	}
}
 
  • 创建可以获取返回值的线程
/**
 * juc中的Callable接口
 * 使主线程可以获得其他线程运行后的返回值
 * 
 * 	1、创建线程池
 * 	2、通过线程池启动线程，并记录返回结果
 * 	3、停止服务
 */
public class CallableTest1 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//创建线程池
		ExecutorService ser = Executors.newFixedThreadPool(2);
		Race rabbit = new Race("小兔子",500);
		Race tortoise = new Race("老不死",1000);
		
		//启动线程、获取值
		Future<Integer> result1 =ser.submit(rabbit);
		Future<Integer> result2 =ser.submit(tortoise);
		
		Thread.sleep(3000);
		rabbit.setFlag(false);
		tortoise.setFlag(false);
		
		int num1 = result1.get();
		int num2 = result2.get();
		ser.shutdownNow();
		System.out.println("兔子跑了 --> "+num1+"步");
		System.out.println("乌龟跑了 --> "+num2+"步");
	}
}

class Race implements Callable<Integer>{
	private String name;	//名字
	private long time;		//延时时间
	private boolean flag=true;
	private int step;		//所走步数
	
	public Race(String name,long time) {
		super();
		this.name = name;
		this.time =time;
	}
	
	@Override
	public Integer call() throws Exception {
		while(flag){
			Thread.sleep(time); //延时
			step++;
		}
		return step;
	}
	
	public String getName() {
		return name;
	}
	public void setFlag(boolean flag) {
		this.flag = flag;
	}
}
 
分享到：
| [初级]设计模式--单例模式
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    VC 初级多线程编程实例源码集.rar

    个人整理的一些比较基础的VC 初级多线程编程实例集，包括安全终止线程、创建UI线程、创建Worker线程、等待线程结束、挂起和恢复线程、获得线程的退出码、使用互斥量、使用临界区、使用信号量等内容，相信对VC 初学者...

    java线程初级学习

    Java线程是Java编程中的重要概念，特别是在处理并发和多任务执行时不可或缺。在Java中，线程允许程序同时执行多个不同的任务，提高了程序的效率和响应性。对于初学者来说，理解线程的基本概念、创建方式以及如何管理...

    多线程入门详解多线程入门详解

    【多线程概念】 多线程是现代操作系统中一种重要的并发执行机制，它允许多个执行流在同一程序中并行运行。在Windows操作系统中，进程是资源分配的基本单位，而线程则是执行的基本单位。一个进程可以包含多个线程，...

    初级多线程文档和视频(学习资料)

    "初级多线程文档和视频"的学习资料包含了理论知识和实践案例，可以帮助初学者理解多线程的基本概念，掌握线程的创建、管理和优化，以及解决并发问题的方法。深入学习并熟练掌握这些知识，对于提升编程技能，尤其是进...

    C#多线程初级入门

    C#多线程初级入门，理论+实例，简单易懂。介绍了线程的基本控制方法。

    多线程断点下载初级版

    多线程断点下载是一种高效的文件下载技术，尤其在处理大文件时，它能显著提高下载速度并允许用户在下载过程中暂停和恢复。这个初级版的实现可能包含以下几个关键知识点： 1. **多线程**：多线程是并发执行多个任务...

    java线程方面的初级学习程序

    本文将深入探讨Java线程的初级知识，包括线程的创建、状态管理、同步机制以及一些常用的线程API。 首先，了解线程的基本概念。在Java中，线程是由`Thread`类表示的。我们可以直接继承`Thread`类或者实现`Runnable`...

    线程（初级）.docx

    ### 线程基础知识 #### 一、线程概述 线程是计算机程序中的最小运行单元，它是在操作系统中能够独立调度和分派的基本单位。一个进程可以包含多个线程，这些线程共享进程的资源（如内存空间），但每个线程有自己的...

    VC 多线程初级应用 实现定时关机功能

    本项目“VC 多线程初级应用 实现定时关机功能”旨在教授初学者如何利用win32 API函数CreateThread来创建一个新的线程，并在该线程中执行定时关机的任务。下面将详细介绍这一过程中的关键知识点。 1. **线程**：线程...

    启动简单的计算线程 Delphi的初级源代码.rar

    本实例"启动简单的计算线程 Delphi的初级源代码"正是为初学者提供了一个良好的起点，帮助他们了解如何在Delphi中实现多线程。 1. **线程基础概念**：线程是操作系统分配处理器时间的基本单位，一个进程可以包含多个...

    java 多线程编程实战指南（核心 + 设计模式 完整版）

    在Java编程领域，多线程是一项至关重要的技术，它能够充分利用多核处理器的计算能力，提高应用程序的响应速度和并发性能。...无论是初级开发者还是经验丰富的工程师，这本书都是一本值得阅读的参考资料。

    线程 - 实例详解(从初级到高级系列讲解)

    ### 线程 - 实例详解(从初级到高级系列讲解) #### 一、绪论与基本概念 在计算机科学领域，线程是程序执行流的最小单位，它被包含在一个进程内，由操作系统调度执行。一个进程可以拥有多个线程，这些线程共享进程内...

    [『辅助』] 易编远航第一期-六套大漠多线程中级进阶视频教程

    使用同步器作为多线程中级教材，主要是对上一套初级教程做一个简单的总结， 并且对接下来脚本的线程处理，及监控线程起到一个较高的实际认知。 对多线程基 础及后续多线程课程有承前启后的作用 主要学习内容： 1....

    多线程项目代码，实例

    本项目提供了多线程的实践案例，涵盖了Delphi、C和C++三种编程语言，适合初级到中级的开发者进行学习和参考。 1. **多线程基础**： - **并发与并行**：多线程可以实现并发执行，即看似同一时间处理多个任务，而...

    python单线程爬虫 源码加初级教程.rar

    在这个“python单线程爬虫 源码加初级教程.rar”压缩包中，包含了一个初级教程和完整的Python源码，非常适合想要学习爬虫技术的新手。我们将深入探讨以下几个关键知识点： 1. **Python基础**：Python是一种广泛使用...

    vb.net多线程例子

    在VB.NET编程中，多线程是一个核心概念，特别是在开发高效、响应迅速的应用程序时。多线程允许程序同时执行多个任务，提高了程序的并行处理能力，减轻了UI线程的压力，使得用户界面能够保持流畅和响应。下面将详细...

    多线程演示程序

    515vc编的多线程演示程序，适合刚学vc多线程功能的初级程序员学习

    C#中异步和多线程的区别

    文档强调，对于那些已经通过了C#开发初级阶段的程序员来说，这是一个非常有价值的学习材料。对于这部分开发者而言，他们需要了解，尽管异步和多线程在某些情况下都可以用来提高应用程序的效率，但它们的工作原理以及...

    多线程程序模拟（不在任何操作系统下运行）.

    实现了单任务多线程的线程切换技术，其中包含了源代码，光盘镜像文件和演示说明。程序是不在任务操作系统运行的程序，由光驱引导运行的。 这里只是演示一下多线程的切换技术和思想，代码存在许多bug，由于cpu的速度...

Magicbox
Global site tag (gtag.js) - Google Analytics