鞋友们，当我们知道线程怎么用时，用的上手了，可是不知道那个是这个线程，所以现在就需要为线程设置名称了
好，那么来一个这个吧从！
方式一：
public final String getName()//获取线程名称
getName() 获取线程名称
public final void setName(String name)
setName() 设置线程名称
方式二：
通过带参构造：public Thread(String name)
好的先来方式一吧：
public final void setName(String name)
public class MyThread extends Thread{
@Override
public void run() {
// TODO Auto-generated method stub
for(int i = 1;i<=10;i++){
String name = getName();
System.out.println(name+"---"+(i+"helloworld"));
}
}
}
public class MyThreadTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建线程对象
MyThread myThread = new MyThread();
MyThread myThread2 = new MyThread();
//启动线程
myThread.start();
myThread2.start();
}
}
public final void setName(String name)
public class MyThreadTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建线程对象
MyThread myThread = new MyThread();
MyThread myThread2 = new MyThread();
//设置线程名称
myThread.setName("小白兔");
myThread2.setName("小乌龟");
//启动线程
myThread.start();
myThread2.start();
}
}
//public Thread(String name)
public class MyThread extends Thread{
@Override
public void run() {
// TODO Auto-generated method stub
for(int i = 1;i<=10;i++){
String name = getName();
System.out.println(name+"---"+(i+"helloworld"));
}
}
/*
注意下面这是这个类是无参构造获取父类方法
*/
public MyThread() {
super();
// TODO Auto-generated constructor stub
}
/*
再注意，下面这个，这个是类的有参构造获取线程名称的
*/
public MyThread(String name) {
super(name);
// TODO Auto-generated constructor stub
}
}
public class MyThreadTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建线程对象
MyThread myThread = new MyThread("小白兔");
MyThread myThread2 = new MyThread("小乌龟");
//设置线程名称
/*myThread.setName("小白兔");
myThread2.setName("小乌龟");*/
//启动线程
myThread.start();
myThread2.start();
}
}
//public static Thread currentThread():返回当前正在执行的线程对象
这个是针对不是thread类的方法想获取线程名称的一个方法
public class MyRunnable implements Runnable{
@Override
public void run() {
// TODO Auto-generated method stub
for(int i = 1;i<=10;i++){
//String name = getName();
//public static Thread currentThread():返回当前正在执行的线程对象
String name = Thread.currentThread().getName();
System.out.println(name+"---"+(i+"helloworld"));
}
}
}
public class MyRunnableTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建MyRunnable类对象
MyRunnable myRunnable = new MyRunnable();
//创建线程对象
Thread thread = new Thread(myRunnable,"小白兔");
Thread thread2 = new Thread(myRunnable,"小乌龟");
//设置线程名称---通过setName()设置
/*thread.setName("小白兔");
thread2.setName("小乌龟");*/
//启动线程
thread.start();
thread2.start();
}
}
接下来呢，我们再说一下线程的优先级吧
线程的优先级其实是线程再运行过程他获取CPU执行权并且以最多的数量来完成的，其他线程也会一次去抢这个CPU的执行权
因为CPU再执行过程中，它的空闲时间很多，为了能有效提高CPU的利用率，所以才会控制线程的优先级的有限数量
不多说了，再来一波吧！！！！
//public final int getPriority()获取优先级
//public final void setPriority(int newPriority) 设置优先级
public class MyThread extends Thread {
@Override
public void run() {
// TODO Auto-generated method stub
for(int i = 1;i<=10;i++){
String name = getName();
System.out.println(name+"---"+i);
}
}
}
public class MyThreadTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建线程对象
MyThread thread = new MyThread();
MyThread thread2 = new MyThread();
//设置线程名称
thread.setName("小白兔");
thread2.setName("小乌龟");
//获取线程优先级
//public final int getPriority() 获取优先级
System.out.println(thread.getPriority());//5
System.out.println(thread2.getPriority());//5
//启动线程
thread.start();
thread2.start();
}
}
线程控制之休眠线程
public class MyThread extends Thread{
@Override
public void run() {
// TODO Auto-generated method stub
for(int i = 1;i<=10;i++){
System.out.println(getName()+"---"+i+"---"+new Date());
try {
Thread.sleep(1000);//让线程休眠1秒
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
public class MyThreadTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建线程对象
MyThread myThread = new MyThread();
MyThread myThread2 = new MyThread();
MyThread myThread3 = new MyThread();
//设置线程名称
myThread.setName("小白兔");
myThread2.setName("小乌龟");
myThread3.setName("小老虎");
//启动线程
myThread.start();
myThread2.start();
myThread3.start();
}
}
线程控制之加入线程
public final void join()：在A线程中调用B线程，让A线程停止，直至B线程执行完之后，A线程再执行。join()方法必须在线程启动后再使用
public class MyThread extends Thread{
@Override
public void run() {
// TODO Auto-generated method stub
for(int i = 1;i<=10;i++){
System.out.println(getName()+"---"+i);
}
}
}
public class MyThreadTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建线程对象
MyThread myThread = new MyThread();
MyThread myThread2 = new MyThread();
MyThread myThread3 = new MyThread();
//设置名称
myThread.setName("小白兔");
myThread2.setName("小乌龟");
myThread3.setName("小老虎");
//启动线程
myThread.start();
try {
myThread.join();//线程启动后，调用该方法
//加入myThread线程，等该线程结束之后，再去执行其他线程
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
myThread2.start();
myThread3.start();
}
}
线程控制之礼让线程
public static void yield()：主动让出cpu的执行权
public class MyThread extends Thread{
@Override
public void run() {
// TODO Auto-generated method stub
for(int i = 1;i<=10;i++){
System.out.println(getName()+"---"+i);
Thread.yield();
}
}
}
public class MyThreadTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建线程对象
MyThread myThread = new MyThread();
MyThread myThread2 = new MyThread();
//设置名称
myThread.setName("熊大");
myThread2.setName("熊二");
//启动线程
myThread.start();
myThread2.start();
//避免一个线程长时间占有 CPU资源,让多个线程的执行更和谐。
}
}
线程控制之守护线程
public class MyThread extends Thread{
@Override
public void run() {
// TODO Auto-generated method stub
for(int i = 1;i<=40;i++){
System.out.println(getName()+"---"+i);
}
}
}
public class MyThreadTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建线程对象
MyThread myThread = new MyThread();
MyThread myThread2 = new MyThread();
MyThread myThread3 = new MyThread();
//设置名称
myThread .setName("主人");
myThread2.setName("护卫A");
myThread3.setName("护卫B");
//将myThread2和myThread3设置为守护线程
//setDaemon方法必须在start方法前定义
myThread2.setDaemon(true);
myThread3.setDaemon(true);
//启动线程
myThread.start();
myThread2.start();
myThread3.start();
//当被守护线程结束后 这些守护线程也会随之结束
}
}
线程控制之中断线程
public final void stop()：强迫线程停止执行。
public void interrupt()：中断线程。
import java.util.Date;
public class MyThread extends Thread{
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println(getName()+"启动了"+new Date());
//让线程睡眠10秒
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
//e.printStackTrace();
System.out.println("线程终止了");
}
System.out.println(getName()+"结束了"+new Date());
}
}
public class MyThreadTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建线程对象
MyThread myThread = new MyThread();
//那如果睡眠时间设置的过长，我不想一直等待，我想等三秒后如果还没反应，就停止
myThread.start();
try {
Thread.sleep(3000);//等待3秒
//myThread.stop();
myThread.interrupt();//将线程状态终止，并抛出一个异常InterruptedException
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//各位看，stop()方法，比较暴力，我等你3秒，你还没反应是不，直接干死
//那如果我想等你3秒，如果没反应，我将你打断，继续往后执行
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
