设置和获取当前线程名称(java代码大全及详解)

设置和获取当前线程名称(java代码大全及详解)

1:多线程(理解)

(1)多线程:一个应用程序有多条执行路径

进程:正在执行的应用程序

线程:进程的执行单元,执行路径

单线程:一个应用程序只有一条执行路径

多线程:一个应用程序有多条执行路径

多进程的意义?

提高CPU的使用率

多线程的意义?

提高应用程序的使用率

(2)Java程序的运行原理及JVM的启动是多线程的吗?

A:Java命令去启动JVM,JVM会启动一个进程,该进程会启动一个主线程。

B:JVM的启动是多线程的,因为它最低有两个线程启动了,主线程和垃圾回收线程。

package cn.itcast_01;

/*

* 进程:

* 正在运行的程序,是系统进行资源分配和调用的独立单位。

* 每一个进程都有它自己的内存空间和系统资源。

* 线程:

* 是进程中的单个顺序控制流,是一条执行路径

* 一个进程如果只有一条执行路径,则称为单线程程序。

* 一个进程如果有多条执行路径,则称为多线程程序。

*

* 举例:

* 扫雷程序,迅雷下载

*

* 大家注意两个词汇的区别:并行和并发。

* 前者是逻辑上同时发生,指在某一个时间内同时运行多个程序。

* 后者是物理上同时发生,指在某一个时间点同时运行多个程序。

*

* Java程序的运行原理:

* 由java命令启动JVM,JVM启动就相当于启动了一个进程。

* 接着有该进程创建了一个主线程去调用main方法。

*

* 思考题:

* jvm虚拟机的启动是单线程的还是多线程的?

* 多线程的。

* 原因是垃圾回收线程也要先启动,否则很容易会出现内存溢出。

* 现在的垃圾回收线程加上前面的主线程,最低启动了两个线程,所以,jvm的启动其实是多线程的。

*/

public class MyThreadDemo {

public static void main(String[] args) {

System.out.println(“hello”);

new Object();

new Object();

new Object();

new Object();

//…

System.out.println(“world”);

}

}

(3)多线程的实现方案(自己补齐步骤及代码 掌握)

A:继承Thread类

package cn.itcast_02;(1)

/*

* 该类要重写run()方法,为什么呢?

* 不是类中的所有代码都需要被线程执行的。

* 而这个时候,为了区分哪些代码能够被线程执行,java提供了Thread类中的run()用来包含那些被线程执行的代码。

*/

public class MyThread extends Thread {

@Override

public void run() {

// 自己写代码

// System.out.println(“好好学习,天天向上”);

// 一般来说,被线程执行的代码肯定是比较耗时的。所以我们用循环改进

for (int x = 0; x < 200; x ) {

System.out.println(x);

}

}

}

package cn.itcast_02;(2)

/*

* 需求:我们要实现多线程的程序。

* 如何实现呢?

* 由于线程是依赖进程而存在的,所以我们应该先创建一个进程出来。

* 而进程是由系统创建的,所以我们应该去调用系统功能创建一个进程。

* Java是不能直接调用系统功能的,所以,我们没有办法直接实现多线程程序。

* 但是呢?Java可以去调用C/C 写好的程序来实现多线程程序。

* 由C/C 去调用系统功能创建进程,然后由Java去调用这样的东西,

* 然后提供一些类供我们使用。我们就可以实现多线程程序了。

* 那么Java提供的类是什么呢?

* Thread

* 通过查看API,我们知道了有2中方式实现多线程程序。

*

* 方式1:继承Thread类。

* 步骤

* A:自定义类MyThread继承Thread类。

* B:MyThread类里面重写run()?

* 为什么是run()方法呢?

* C:创建对象

* D:启动线程

*/

public class MyThreadDemo {

public static void main(String[] args) {

// 创建线程对象

// MyThread my = new MyThread();

// // 启动线程

// my.run();

// my.run();

// 调用run()方法为什么是单线程的呢?

// 因为run()方法直接调用其实就相当于普通的方法调用,所以你看到的是单线程的效果

// 要想看到多线程的效果,就必须说说另一个方法:start()

// 面试题:run()和start()的区别?

// run():仅仅是封装被线程执行的代码,直接调用是普通方法

// start():首先启动了线程,然后再由jvm去调用该线程的run()方法。

// MyThread my = new MyThread();

// my.start();

// // IllegalThreadStateException:非法的线程状态异常

// // 为什么呢?因为这个相当于是my线程被调用了两次。而不是两个线程启动。

// my.start();

// 创建两个线程对象

MyThread my1 = new MyThread();

MyThread my2 = new MyThread();

my1.start();

my2.start();

}

}

B:实现Runnable接口

package cn.itcast_05;(1)

public class MyRunnable implements Runnable {

@Override

public void run() {

for (int x = 0; x < 100; x ) {

// 由于实现接口的方式就不能直接使用Thread类的方法了,但是可以间接的使用

System.out.println(Thread.currentThread().getName() “:” x);

}

}

}

package cn.itcast_05;(2)

/*

* 方式2:实现Runnable接口

* 步骤:

* A:自定义类MyRunnable实现Runnable接口

* B:重写run()方法

* C:创建MyRunnable类的对象

* D:创建Thread类的对象,并把C步骤的对象作为构造参数传递

*/

public class MyRunnableDemo {

public static void main(String[] args) {

// 创建MyRunnable类的对象

MyRunnable my = new MyRunnable();

// 创建Thread类的对象,并把C步骤的对象作为构造参数传递

// Thread(Runnable target)

// Thread t1 = new Thread(my);

// Thread t2 = new Thread(my);

// t1.setName(“林青霞”);

// t2.setName(“刘意”);

// Thread(Runnable target, String name)

Thread t1 = new Thread(my, “林青霞”);

Thread t2 = new Thread(my, “刘意”);

t1.start();

t2.start();

}

}

(4)线程的名字获取与设置

package cn.itcast_03;(1)

public class MyThread extends Thread {

public MyThread() {

}

public MyThread(String name){

super(name);

}

@Override

public void run() {

for (int x = 0; x < 100; x ) {

System.out.println(getName() “:” x);

}

}

}

package cn.itcast_03;(2)

/*

* 如何获取线程对象的名称呢?

* public final String getName():获取线程的名称。

* 如何设置线程对象的名称呢?

* public final void setName(String name):设置线程的名称

*

* 针对不是Thread类的子类中如何获取线程对象名称呢?

* public static Thread currentThread():返回当前正在执行的线程对象

* Thread.currentThread().getName()

*/

public class MyThreadDemo {

public static void main(String[] args) {

// 创建线程对象

//无参构造 setXxx()

// MyThread my1 = new MyThread();

// MyThread my2 = new MyThread();

// //调用方法设置名称

// my1.setName(“林青霞”);

// my2.setName(“刘意”);

// my1.start();

// my2.start();

//带参构造方法给线程起名字

// MyThread my1 = new MyThread(“林青霞”);

// MyThread my2 = new MyThread(“刘意”);

// my1.start();

// my2.start();

//我要获取main方法所在的线程对象的名称,该怎么办呢?

//遇到这种情况,Thread类提供了一个很好玩的方法:

//public static Thread currentThread():返回当前正在执行的线程对象

System.out.println(Thread.currentThread().getName());

}

}

/*

名称为什么是:Thread-? 编号

class Thread {

private char name[];

public Thread() {

init(null, null, “Thread-” nextThreadNum(), 0);

}

private void init(ThreadGroup g, Runnable target, String name,

long stackSize) {

init(g, target, name, stackSize, null);

}

private void init(ThreadGroup g, Runnable target, String name,

long stackSize, AccessControlContext acc) {

//大部分代码被省略了

this.name = name.toCharArray();

}

public final void setName(String name) {

this.name = name.toCharArray();

}

private static int threadInitNumber; //0,1,2

private static synchronized int nextThreadNum() {

return threadInitNumber ; //return 0,1

}

public final String getName() {

return String.valueOf(name);

}

}

class MyThread extends Thread {

public MyThread() {

super();

}

}

*/

(5)线程的调度和优先级问题

A:线程的调度

a:分时调度

b:抢占式调度 (Java采用的是该调度方式)

B:获取和设置线程优先级

a:默认是5

b:范围是1-10

package cn.itcast_04;(1)

public class ThreadPriority extends Thread {

@Override

public void run() {

for (int x = 0; x < 100; x ) {

System.out.println(getName() “:” x);

}

}

}

package cn.itcast_04;(2)

/*

* 我们的线程没有设置优先级,肯定有默认优先级。

* 那么,默认优先级是多少呢?

* 如何获取线程对象的优先级?

* public final int getPriority():返回线程对象的优先级

* 如何设置线程对象的优先级呢?

* public final void setPriority(int newPriority):更改线程的优先级。

*

* 注意:

* 线程默认优先级是5。

* 线程优先级的范围是:1-10。

* 线程优先级高仅仅表示线程获取的 CPU时间片的几率高,但是要在次数比较多,或者多次运行的时候才能看到比较好的效果。

*

* IllegalArgumentException:非法参数异常。

* 抛出的异常表明向方法传递了一个不合法或不正确的参数。

*

*/

public class ThreadPriorityDemo {

public static void main(String[] args) {

ThreadPriority tp1 = new ThreadPriority();

ThreadPriority tp2 = new ThreadPriority();

ThreadPriority tp3 = new ThreadPriority();

tp1.setName(“东方不败”);

tp2.setName(“岳不群”);

tp3.setName(“林平之”);

// 获取默认优先级

// System.out.println(tp1.getPriority());

// System.out.println(tp2.getPriority());

// System.out.println(tp3.getPriority());

// 设置线程优先级

// tp1.setPriority(100000);

//设置正确的线程优先级

tp1.setPriority(10);

tp2.setPriority(1);

tp1.start();

tp2.start();

tp3.start();

}

}

(6)线程的控制(常见方法)

A:休眠线程

package cn.itcast_04;(1)

import java.util.Date;

public class ThreadSleep extends Thread {

@Override

public void run() {

for (int x = 0; x < 100; x ) {

System.out.println(getName() “:” x “,日期:” new Date());

// 睡眠

// 困了,我稍微休息1秒钟

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

package cn.itcast_04;(2)

/*

* 线程休眠

* public static void sleep(long millis)

*/

public class ThreadSleepDemo {

public static void main(String[] args) {

ThreadSleep ts1 = new ThreadSleep();

ThreadSleep ts2 = new ThreadSleep();

ThreadSleep ts3 = new ThreadSleep();

ts1.setName(“林青霞”);

ts2.setName(“林志玲”);

ts3.setName(“林志颖”);

ts1.start();

ts2.start();

ts3.start();

}

}

B:加入线程(等待该线程终止)

package cn.itcast_04;(1)

public class ThreadJoin extends Thread {

@Override

public void run() {

for (int x = 0; x < 100; x ) {

System.out.println(getName() “:” x);

}

}

}

package cn.itcast_04;(2)

/*

* public final void join():等待该线程终止。

*/

public class ThreadJoinDemo {

public static void main(String[] args) {

ThreadJoin tj1 = new ThreadJoin();

ThreadJoin tj2 = new ThreadJoin();

ThreadJoin tj3 = new ThreadJoin();

tj1.setName(“李渊”);

tj2.setName(“李世民”);

tj3.setName(“李元霸”);

tj1.start();

try {

tj1.join();

} catch (InterruptedException e) {

e.printStackTrace();

}

tj2.start();

tj3.start();

}

}

C:礼让线程

package cn.itcast_04;(1)

public class ThreadYield extends Thread {

@Override

public void run() {

for (int x = 0; x < 100; x ) {

System.out.println(getName() “:” x);

Thread.yield();

}

}

}

package cn.itcast_04;(2)

/*

* public static void yield():暂停当前正在执行的线程对象,并执行其他线程。

* 让多个线程的执行更和谐,但是不能靠它保证一人一次。

*/

public class ThreadYieldDemo {

public static void main(String[] args) {

ThreadYield ty1 = new ThreadYield();

ThreadYield ty2 = new ThreadYield();

ty1.setName(“林青霞”);

ty2.setName(“刘意”);

ty1.start();

ty2.start();

}

}

D:后台线程

package cn.itcast_04;(1)

public class ThreadDaemon extends Thread {

@Override

public void run() {

for (int x = 0; x < 100; x ) {

System.out.println(getName() “:” x);

}

}

}

package cn.itcast_04;(2)

/*

* public final void setDaemon(boolean on):将该线程标记为守护线程或用户线程。

* 当正在运行的线程都是守护线程时,Java 虚拟机退出。 该方法必须在启动线程前调用。

*

* 游戏:坦克大战。

*/

public class ThreadDaemonDemo {

public static void main(String[] args) {

ThreadDaemon td1 = new ThreadDaemon();

ThreadDaemon td2 = new ThreadDaemon();

td1.setName(“关羽”);

td2.setName(“张飞”);

// 设置收获线程

td1.setDaemon(true);

td2.setDaemon(true);

td1.start();

td2.start();

Thread.currentThread().setName(“刘备”);

for (int x = 0; x < 5; x ) {

System.out.println(Thread.currentThread().getName() “:” x);

}

}

}

E:终止线程(掌握)

package cn.itcast_04;(1)

import java.util.Date;

public class ThreadStop extends Thread {

@Override

public void run() {

System.out.println(“开始执行:” new Date());

// 我要休息10秒钟,亲,不要打扰我哦

try {

Thread.sleep(10000);

} catch (InterruptedException e) {

// e.printStackTrace();

System.out.println(“线程被终止了”);

}

System.out.println(“结束执行:” new Date());

}

}

package cn.itcast_04;(2)

/*

* public final void stop():让线程停止,过时了,但是还可以使用。

* public void interrupt():中断线程。 把线程的状态终止,并抛出一个InterruptedException。

*/

public class ThreadStopDemo {

public static void main(String[] args) {

ThreadStop ts = new ThreadStop();

ts.start();

// 你超过三秒不醒过来,我就干死你

try {

Thread.sleep(3000);

// ts.stop();

ts.interrupt();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

你需要的是什么,直接评论留言。

还有“Java帮帮”今日头条号,技术文章与新闻,每日更新,欢迎阅读

分享是一种美德,分享更快乐!

发表评论

登录后才能评论