Java多线程编程(二)操作状态与常用方法

线程的状态:

1.线程也有固定的操作状态:

创建状态:准备好了一个多线程的对象(也就是new出来一个Thread对象)

就绪状态:调用了start()方法,等待CPU进行调度(等待CPU分配资源的状态)

运行状态:执行run()方法(当CPU分配好资源或CPU已经进行调度,此时处于运行状态)

阻塞状态:暂时停止执行,可能将资源交给其他线程使用(可再恢复到运行状态)

终止状态(死亡状态):线程销毁(最终当整个线程执行完毕之后,线程自动销毁)

线程的常用方法:

线程的常用方法大都存在于Thread类当中,所以大多时候我们通过Thread类进行调用。

1.取得线程名称

getName()

2.取得当前线程对象

currentThread()

3.判断线程是否启动

isAlive()

4.线程的强行运行

join()

5.线程的休眠

sleep()

6.线程的礼让(针对声明周期是非常重要的)

yield()

代码演示:(1、2)

package com.yeqc.thread;

class RunableDemo implements Runnable{
	private String name;
	public RunableDemo(String name) {
		this.name = name;
	}

	@Override
	public void run() {
		for (int i = 0; i < 50; i++) {
			System.out.println("当前线程对象:"+Thread.currentThread().getName());
		}
	}

}

public class ThreadDemo02 {

	public static void main(String[] args) {
		RunableDemo r1 = new RunableDemo("A");
		RunableDemo r2 = new RunableDemo("B");
		Thread t1 = new Thread(r1);
		Thread t2 = new Thread(r2);
		t1.start();
		t2.start();
	}

}

运行结果:

当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-0
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1
当前线程对象:Thread-1

代码演示:(3.判断线程是否启动)

package com.yeqc.thread;

class RunableDemo implements Runnable{
	private String name;
	public RunableDemo(String name) {
		this.name = name;
	}

	@Override
	public void run() {
		for (int i = 0; i < 50; i++) {
			System.out.println(name+":"+i);
		}
	}

}

public class ThreadDemo02 {

	public static void main(String[] args) {
		RunableDemo r = new RunableDemo("A");
		Thread t = new Thread(r);
		System.out.println(t.isAlive());
		t.start();
		System.out.println(t.isAlive());
	}

}

运行结果:

false
true
A:0
A:1
A:2
A:3
A:4
A:5
A:6
A:7
A:8
A:9
A:10
A:11
A:12
A:13
A:14
A:15
A:16
A:17
A:18
A:19
A:20
A:21
A:22
A:23
A:24
A:25
A:26
A:27
A:28
A:29
A:30
A:31
A:32
A:33
A:34
A:35
A:36
A:37
A:38
A:39
A:40
A:41
A:42
A:43
A:44
A:45
A:46
A:47
A:48
A:49

代码演示(4.线程的强行运行)

package com.yeqc.thread;

class RunableDemo implements Runnable{
	private String name;
	public RunableDemo(String name) {
		this.name = name;
	}

	@Override
	public void run() {
		for (int i = 0; i < 50; i++) {
			System.out.println(name+":"+i);
		}
	}

}

public class ThreadDemo02 {

	public static void main(String[] args) {
		RunableDemo r = new RunableDemo("A");
		Thread t = new Thread(r);
		t.start();
		for(int i=0; i<50; i++){
			if (i>10) {
				try {
					t.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("主线程:"+i);
		}
	}

}

运行结果:

主线程:0
A:0
主线程:1
A:1
主线程:2
A:2
主线程:3
A:3
主线程:4
A:4
主线程:5
A:5
主线程:6
A:6
主线程:7
A:7
主线程:8
A:8
主线程:9
A:9
主线程:10
A:10
A:11
A:12
A:13
A:14
A:15
A:16
A:17
A:18
A:19
A:20
A:21
A:22
A:23
A:24
A:25
A:26
A:27
A:28
A:29
A:30
A:31
A:32
A:33
A:34
A:35
A:36
A:37
A:38
A:39
A:40
A:41
A:42
A:43
A:44
A:45
A:46
A:47
A:48
A:49
主线程:11
主线程:12
主线程:13
主线程:14
主线程:15
主线程:16
主线程:17
主线程:18
主线程:19
主线程:20
主线程:21
主线程:22
主线程:23
主线程:24
主线程:25
主线程:26
主线程:27
主线程:28
主线程:29
主线程:30
主线程:31
主线程:32
主线程:33
主线程:34
主线程:35
主线程:36
主线程:37
主线程:38
主线程:39
主线程:40
主线程:41
主线程:42
主线程:43
主线程:44
主线程:45
主线程:46
主线程:47
主线程:48
主线程:49

代码演示(5.线程的休眠)

package com.yeqc.thread;

class RunableDemo implements Runnable{
	private String name;
	public RunableDemo(String name) {
		this.name = name;
	}

	@Override
	public void run() {
		for (int i = 0; i < 50; i++) {
			try {
				Thread.sleep(1000);
				System.out.println(name+":"+i);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

}

public class ThreadDemo02 {

	public static void main(String[] args) {
		RunableDemo r = new RunableDemo("A");
		Thread t = new Thread(r);
		t.start();
	}

}

运行结果(每1s执行一次)

A:0
A:1
A:2
A:3
A:4
A:5
A:6
A:7
A:8
A:9
A:10
A:11
A:12
A:13
A:14
A:15
A:16
A:17
A:18
A:19
A:20
A:21
A:22
A:23
A:24
A:25
A:26
A:27
A:28
A:29
A:30
A:31
A:32
A:33
A:34
A:35
A:36
A:37
A:38
A:39
A:40
A:41
A:42
A:43
A:44
A:45
A:46
A:47
A:48
A:49

代码演示(6.线程的礼让)

package com.yeqc.thread;

class RunableDemo implements Runnable{
	private String name;
	public RunableDemo(String name) {
		this.name = name;
	}

	@Override
	public void run() {
		for (int i = 0; i < 50; i++) {
			System.out.println(name+":"+i);
			if (i == 10) {
				System.out.println("礼让");
				Thread.yield();
			}
		}
	}

}

public class ThreadDemo02 {

	public static void main(String[] args) {
		RunableDemo r1 = new RunableDemo("A");
		RunableDemo r2 = new RunableDemo("B");
		Thread t1 = new Thread(r1);
		Thread t2 = new Thread(r2);
		t1.start();
		t2.start();
	}

}

运行结果:

A:0
B:0
A:1
A:2
A:3
B:1
A:4
B:2
A:5
B:3
A:6
B:4
A:7
B:5
A:8
B:6
A:9
B:7
A:10
B:8
礼让
B:9
A:11
B:10
礼让
A:12
B:11
A:13
B:12
A:14
B:13
A:15
B:14
A:16
B:15
A:17
B:16
A:18
B:17
A:19
B:18
A:20
B:19
A:21
B:20
A:22
B:21
A:23
B:22
A:24
B:23
A:25
B:24
A:26
B:25
A:27
A:28
B:26
A:29
B:27
A:30
B:28
A:31
B:29
A:32
B:30
A:33
B:31
A:34
B:32
A:35
B:33
A:36
B:34
A:37
B:35
A:38
B:36
A:39
B:37
A:40
B:38
A:41
B:39
A:42
B:40
A:43
B:41
A:44
B:42
A:45
A:46
B:43
B:44
B:45
B:46
A:47
A:48
B:47
B:48
B:49
A:49
时间: 2024-08-14 23:22:32

Java多线程编程(二)操作状态与常用方法的相关文章

java多线程编程(二创建线程)

1.概念           因为java是完全面向对象的,所以在java中,我们说的线程,就是Thread类的一个实例对象.所以,一个线程就是一个对象,它有自己字段和方法. 2.创建线程 创建线程有2种方法:1.扩展线程父类Thread类 , 2.实现Runnable接口.2种方法是由区别的. 提示:Thread类已经实现了Runnable接口,Thread类中不但实现了run方法,也定义了更多的,全面的线程对象的操作方法,而Runnable接口中只有run这一个方法. 通过扩展Thread类

java多线程编程(二)

wait 和 sleep 区别? 1.wait可以指定时间也可以不指定,sleep必须指定时间. 2.在同步中时,对cpu的执行权和锁的处理不同.  wait:释放执行权,释放锁.  sleep:释放执行权,不释放锁.

Java多线程编程模式实战指南(二):Immutable Object模式--转载

本文由本人首次发布在infoq中文站上:http://www.infoq.com/cn/articles/java-multithreaded-programming-mode-immutable-object.转载请注明作者: 黄文海 出处:http://viscent.iteye.com. 多线程共享变量的情况下,为了保证数据一致性,往往需要对这些变量的访问进行加锁.而锁本身又会带来一些问题和开销.Immutable Object模式使得我们可以在不使用锁的情况下,既保证共享变量访问的线程安

Java多线程编程(二)

在 Java多线程编程(一) 中的多线程并没有返回值,本文将介绍带返回值的多线程. 要想有返回值,则需要实现新的接口Callable而不再是Runnable接口,实现的方法也改为call()方法,执行器也不再是调用execute(),而是submit() [程序实例] 1 public class TaskWithResult implements Callable<String> { 2 3 private int id; 4 5 public TaskWithResult(int id)

Java多线程编程详解

线程的同步 由于同一进程的多个线程共享同一片存储空间,在带来方便的同时,也带来了访问冲突这个严重的问题.Java语言提供了专门机制以解决这种冲突,有效避免了同一个数据对象被多个线程同时访问. 由于我们可以通过 private 关键字来保证数据对象只能被方法访问,所以我们只需针对方法提出一套机制,这套机制就是 synchronized 关键字,它包括两种用法:synchronized 方法和 synchronized 块. 1. synchronized 方法:通过在方法声明中加入 synch

java多线程编程从入门到卓越(超详细总结)

导读:java多线程编程不太熟?或是听说过?或是想复习一下?找不到好的文章?别担心我给你们又安利一波,文章内容很全,并且考虑到很多开发中遇到的问题和解决方案.循环渐进,通俗易懂,文章较长,建议收藏再看! 往期精彩放送:一文搞定Java的输入输出流等常见流 一文搞定Java集合类,你还在为Java集合类而烦恼吗? 文章目录 1.多线程的概念 2.多线程并发 3.多线程程序设计 继承Thread类创建线程 新建类实现Runnable接口创建线程 改进(匿名内部类方式) 获取线程的名字和当前线程对象

java多线程编程

一.多线程的优缺点 多线程的优点: 1)资源利用率更好2)程序设计在某些情况下更简单3)程序响应更快 多线程的代价: 1)设计更复杂虽然有一些多线程应用程序比单线程的应用程序要简单,但其他的一般都更复杂.在多线程访问共享数据的时候,这部分代码需要特别的注意.线程之间的交互往往非常复杂.不正确的线程同步产生的错误非常难以被发现,并且重现以修复. 2)上下文切换的开销当CPU从执行一个线程切换到执行另外一个线程的时候,它需要先存储当前线程的本地的数据,程序指针等,然后载入另一个线程的本地数据,程序指

Java多线程编程基础之线程对象

在进入java平台的线程对象之前,基于基础篇(一)的一些问题,我先插入两个基本概念. [线程的并发与并行] 在单CPU系统中,系统调度在某一时刻只能让一个线程运行,虽然这种调试机制有多种形式(大多数是时间片轮巡为主),但无论如何,要通过不断切换需要运行的线程让其运行的方式就叫并发(concurrent).而在多CPU系统中,可以让两个以上的线程同时运行,这种可以同时让两个以上线程同时运行的方式叫做并行(parallel). 在上面包括以后的所有论述中,请各位朋友谅解,我无法用最准确的词语来定义储

Java多线程编程(学习笔记)

一.说明 周末抽空重新学习了下多线程,为了方便以后查阅,写下学习笔记. 有效利用多线程的关键是理解程序是并发执行而不是串行执行的.例如:程序中有两个子系统需要并发执行,这时候需要利用多线程编程. 通过多线程的使用,可以编写出非常高效的程序.但如果创建了太多的线程,程序执行的效率反而会降低. 同时上下文的切换开销也很重要,如果创建太多的线程,CPU花费在上下文的切换时间将对于执行程序的时间. 二.Java多线程编程 概念 在学习多线程时,我们应该首先明白另外一个概念. 进程:是计算机中的程序关于某

Java多线程编程要点

Java多线程编程要点 认识Thread和Runnable Java中 实现多线程有两种途径:继承Thread类或者实现Runnable接口.Runnable是接口,建议用接口的方式生成线程,因为接口可以实现多继承, 况且Runnable只有一个run方法,很适合继承.在使用Thread的时候只需继承Thread,并且new一个实例出来,调用 start()方法即可以启动一个线程. Thread Test = new Thread(); Test.start(); 在使用Runnable的时候需