Java多线程--线程常用操作方法

1、取得和设置线程名称

class MyThread implements Runnable{	// 实现Runnable接口
	public void run(){	// 覆写run()方法
		for(int i=0;i<3;i++){
			System.out.println(Thread.currentThread().getName()
					+ "运行,i = " + i) ;	// 取得当前线程的名字
		}
	}
};
public class ThreadNameDemo{
	public static void main(String args[]){
		MyThread mt = new MyThread() ;	// 实例化Runnable子类对象
		new Thread(mt).start() ;		// 系统自动设置线程名称
		new Thread(mt,"线程-A").start() ;		// 手工设置线程名称
		new Thread(mt,"线程-B").start() ;		// 手工设置线程名称
		new Thread(mt).start() ;		// 系统自动设置线程名称
		new Thread(mt).start() ;		// 系统自动设置线程名称
	}
};

2、取得当前线程 currentThread()

class MyThread implements Runnable{	// 实现Runnable接口
	public void run(){	// 覆写run()方法
		for(int i=0;i<3;i++){
			System.out.println(Thread.currentThread().getName()
					+ "运行,i = " + i) ;	// 取得当前线程的名字
		}
	}
};
public class CurrentThreadDemo{
	public static void main(String args[]){
		MyThread mt = new MyThread() ;	// 实例化Runnable子类对象
		new Thread(mt,"线程").start() ;		// 启动线程
		mt.run() ;	// 直接调用run()方法
	}
};

3、判断线程是否启动  isAlive()

class MyThread implements Runnable{	// 实现Runnable接口
	public void run(){	// 覆写run()方法
		for(int i=0;i<3;i++){
			System.out.println(Thread.currentThread().getName()
					+ "运行,i = " + i) ;	// 取得当前线程的名字
		}
	}
};
public class ThreadAliveDemo{
	public static void main(String args[]){
		MyThread mt = new MyThread() ;	// 实例化Runnable子类对象
		Thread t = new Thread(mt,"线程");		// 实例化Thread对象
		System.out.println("线程开始执行之前 --> " + t.isAlive()) ;	 // 判断是否启动
		t.start() ;	// 启动线程
		System.out.println("线程开始执行之后 --> " + t.isAlive()) ;	 // 判断是否启动
		for(int i=0;i<3;i++){
			System.out.println(" main运行 --> " + i) ;
		}
		// 以下的输出结果不确定
		System.out.println("代码执行之后 --> " + t.isAlive()) ;	 // 判断是否启动

	}
};

4、线程的强制执行 join()

class MyThread implements Runnable{	// 实现Runnable接口
	public void run(){	// 覆写run()方法
		for(int i=0;i<50;i++){
			System.out.println(Thread.currentThread().getName()
					+ "运行,i = " + i) ;	// 取得当前线程的名字
		}
	}
};
public class ThreadJoinDemo{
	public static void main(String args[]){
		MyThread mt = new MyThread() ;	// 实例化Runnable子类对象
		Thread t = new Thread(mt,"线程");		// 实例化Thread对象
		t.start() ;	// 启动线程
		for(int i=0;i<50;i++){
			if(i>10){
				try{
					t.join() ;	// 线程强制运行
				}catch(InterruptedException e){}
			}
			System.out.println("Main线程运行 --> " + i) ;
		}
	}
};

5、线程的休眠   sleep()

class MyThread implements Runnable{	// 实现Runnable接口
	public void run(){	// 覆写run()方法
		for(int i=0;i<50;i++){
			try{
					Thread.sleep(500) ;	// 线程休眠
			}catch(InterruptedException e){}
			System.out.println(Thread.currentThread().getName()
					+ "运行,i = " + i) ;	// 取得当前线程的名字
		}
	}
};
public class ThreadSleepDemo{
	public static void main(String args[]){
		MyThread mt = new MyThread() ;	// 实例化Runnable子类对象
		Thread t = new Thread(mt,"线程");		// 实例化Thread对象
		t.start() ;	// 启动线程
	}
};

6、线程的中断   interrupt()

class MyThread implements Runnable{	// 实现Runnable接口
	public void run(){	// 覆写run()方法
		System.out.println("1、进入run()方法") ;
		try{
				Thread.sleep(10000) ;	// 线程休眠10秒
				System.out.println("2、已经完成了休眠") ;
		}catch(InterruptedException e){
			System.out.println("3、休眠被终止") ;
			return ; // 返回调用处
		}
		System.out.println("4、run()方法正常结束") ;
	}
};
public class ThreadInterruptDemo{
	public static void main(String args[]){
		MyThread mt = new MyThread() ;	// 实例化Runnable子类对象
		Thread t = new Thread(mt,"线程");		// 实例化Thread对象
		t.start() ;	// 启动线程
		try{
				Thread.sleep(2000) ;	// 线程休眠2秒
		}catch(InterruptedException e){

		}
		t.interrupt() ;	// 中断线程执行
	}
};

7、后台线程 setDaemon()

class MyThread implements Runnable{	// 实现Runnable接口
	public void run(){	// 覆写run()方法
		while(true){
			System.out.println(Thread.currentThread().getName() + "在运行。") ;
		}
	}
};
public class ThreadDaemonDemo{
	public static void main(String args[]){
		MyThread mt = new MyThread() ;	// 实例化Runnable子类对象
		Thread t = new Thread(mt,"线程");		// 实例化Thread对象
		t.setDaemon(true) ;	// 此线程在后台运行
		t.start() ;	// 启动线程
	}
};

8、线程的优先级 setPriority()

class MyThread implements Runnable{	// 实现Runnable接口
	public void run(){	// 覆写run()方法
		for(int i=0;i<5;i++){
			try{
					Thread.sleep(500) ;	// 线程休眠
			}catch(InterruptedException e){}
			System.out.println(Thread.currentThread().getName()
					+ "运行,i = " + i) ;	// 取得当前线程的名字
		}
	}
};
public class ThreadPriorityDemo{
	public static void main(String args[]){
		Thread t1 = new Thread(new MyThread(),"线程A") ;	// 实例化线程对象
		Thread t2 = new Thread(new MyThread(),"线程B") ;	// 实例化线程对象
		Thread t3 = new Thread(new MyThread(),"线程C") ;	// 实例化线程对象
		t1.setPriority(Thread.MIN_PRIORITY) ;	// 优先级最低
		t2.setPriority(Thread.MAX_PRIORITY) ;	// 优先级最高
		t3.setPriority(Thread.NORM_PRIORITY) ;	// 优先级中等
		t1.start() ;	// 启动线程
		t2.start() ;	// 启动线程
		t3.start() ;	// 启动线程
	}
};

public class MainPriorityDemo{
	public static void main(String args[]){
		System.out.println("主方法的优先级:" +
			Thread.currentThread().getPriority()) ;	// 取得主方法的优先级
		System.out.println("MAX_PRIORITY = " + Thread.MAX_PRIORITY) ;
		System.out.println("NORM_PRIORITY = " + Thread.NORM_PRIORITY) ;
		System.out.println("MIN_PRIORITY = " + Thread.MIN_PRIORITY) ;
	}
};

9、线程的礼让 yield()

class MyThread implements Runnable{	// 实现Runnable接口
	public void run(){	// 覆写run()方法
		for(int i=0;i<5;i++){
			try{
				Thread.sleep(500) ;
			}catch(Exception e){}
			System.out.println(Thread.currentThread().getName()
					+ "运行,i = " + i) ;	// 取得当前线程的名字
			if(i==2){
				System.out.print("线程礼让:") ;
				Thread.currentThread().yield() ;	// 线程礼让
			}
		}
	}
};
public class ThreadYieldDemo{
	public static void main(String args[]){
		MyThread my = new MyThread() ;	// 实例化MyThread对象
		Thread t1 = new Thread(my,"线程A") ;
		Thread t2 = new Thread(my,"线程B") ;
		t1.start() ;
		t2.start() ;
	}
};

时间: 2024-12-06 19:48:09

Java多线程--线程常用操作方法的相关文章

java 多线程-线程通信实例讲解_java

线程通信的目标是使线程间能够互相发送信号.另一方面,线程通信使线程能够等待其他线程的信号. 通过共享对象通信 忙等待 wait(),notify()和 notifyAll() 丢失的信号 假唤醒 多线程等待相同信号 不要对常量字符串或全局对象调用 wait() 通过共享对象通信 线程间发送信号的一个简单方式是在共享对象的变量里设置信号值.线程 A 在一个同步块里设置 boolean 型成员变量 hasDataToProcess 为 true,线程 B 也在同步块里读取 hasDataToProc

Java多线程-线程的同步与锁的问题_java

一.同步问题提出 线程的同步是为了防止多个线程访问一个数据对象时,对数据造成的破坏. 例如:两个线程ThreadA.ThreadB都操作同一个对象Foo对象,并修改Foo对象上的数据. package cn.thread; public class Foo { private int x = 100; public int getX() { return x; } public int fix(int y) { x = x - y; return x; } } package cn.thread

java多线程:线程体往外抛出异常的处理机制实践

1当线程的线程体内部无捕获异常,将异常抛出线程体外,不同情况下,程序处理机制 测试类 1 package com.ehking.bankchannel.domesticremit.facade.impl; 2 3 import java.util.ArrayList; 4 import java.util.List; 5 import java.util.concurrent.Executor; 6 import java.util.concurrent.Executors; 7 8 9 pub

Java多线程--线程操作范例

1.实例要求 设计一个线程操作类,要求可以产生三个线程对象,并可以分别设置三个线程的休眠时间: 线程A : 休眠10秒 线程B: 休眠20秒 线程C : 休眠30秒 2.通过继承Thread类 在Thread类中直接存在了name属性. class MyThread extends Thread{ private int time ; public MyThread(String name,int time){ super(name) ; // 设置线程名称 this.time = time ;

学习Java多线程之线程定义、状态和属性_java

一 .线程和进程 1. 什么是线程和进程的区别: 线程是指程序在执行过程中,能够执行程序代码的一个执行单元.在java语言中,线程有四种状态:运行 .就绪.挂起和结束. 进程是指一段正在执行的程序.而线程有事也被成为轻量级的进程,他得程序执行的最小单元,一个进程可以拥有多个线程,各个线程之间共享程序的内功空间(代码段.数据段和堆空间)及一些进程级的资源(例如打开的文件),但是各个线程都拥有自己的棧空间. 2. 为何要使用多进程 在操作系统级别上来看主要有以下几个方面: - 使用多线程可以减少程序

java 多线程和线程池

● 多线程 多线程的概念很好理解就是多条线程同时存在,但要用好多线程确不容易,涉及到多线程间通信,多线程共用一个资源等诸多问题. 使用多线程的优缺点: 优点: 1)适当的提高程序的执行效率(多个线程同时执行). 2)适当的提高了资源利用率(CPU.内存等). 缺点: 1)占用一定的内存空间. 2)线程越多CPU的调度开销越大. 3)程序的复杂度会上升. 对于多线程的示例代码感兴趣的可以自己写Demo啦,去运行体会,下面我主要列出一些多线程的技术点. synchronized 同步块大家都比较熟悉

Java多线程:“基础篇”05之线程等待与唤醒

wait(), notify(), notifyAll()等方法介绍 在Object.java中,定义了wait(), notify()和notifyAll()等接口.wait()的作用是让当前线程进入 等待状态,同时,wait()也会让当前线程释放它所持有的锁.而notify()和notifyAll()的作用,则是唤 醒当前对象上的等待线程:notify()是唤醒单个线程,而notifyAll()是唤醒所有的线程. Object类中关于等待/唤醒的API详细信息如下: notify()    

Java多线程同步问题的探究(一、线程的先来后到)

众所周知,在Java多线程编程中,一个非常重要的方面就是线程的同步问题. 关于线程的同步,一般有以下解决方法: 1. 在需要同步的方法的方法签名中加入synchronized关键字. 2. 使用synchronized块对需要进行同步的代码段进行同步. 3. 使用JDK 5中提供的java.util.concurrent.lock包中的Lock对象. 另外,为了解决多个线程对同一变量进行访问时可能发生的安全性问题,我们不仅可以采用同步机制,更可以通过JDK 1.2中加入的 ThreadLocal

新手学JAVA(十)-多线程----线程的创建和启动

Java使用Thread类代表线程,所有的线程对象都必须是Thread类或者其子类的实例.每个下次你哼的作用是完成一定的任务,实际上就是执行一段程序流(一段顺序执行的代码).Java使用线程执行体来代表这段程序流     在Java线程的创建有三种方式      通过继承Thread类创建线程类 步骤如下 定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务.因此把run()方法称为线程执行体. 创建Thread子类的实例,即创建了线程的对象.