标签：就会 toc 选中 线程状态 优先级 nts 工作 性能 多任务
代码如下:
//1. 继承thread类，重写run方法，run方法中，需要线程执行代码
class ThreadDemo01 extends Thread {
// run方法中，需要线程需要执行代码
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.print("子线程id:" + this.getId() + ",");
System.out.print("子线程name:" + getName()+",");
System.out.println("子线程--->i:" + i);
}
}
}
// 1.什么是线程 线程是一条执行路径，每个线程都互不影响。
// 2.什么是多线程，多线程在一个进程中，有多条不同的执行路径，并行执行。目的为了提高程序效率。
// 3.在一个进程中，一定会主线程。
// 4.如果连线程主线程都没有，怎么执行程序。
// 线程几种分类 1. 用户线程、守护线程
// 2. 主线程 子线程 GC线程
public class T001_CreateWithThread {
// 交替执行
public static void main(String[] args) {
System.out.println("main... 主线程开始...");
// 1.创建线程
ThreadDemo01 threadDemo01 = new ThreadDemo01();
// 2.启动线程
threadDemo01.start();
for (int i = 0; i < 10; i++) {
System.out.println("main---> i: " + i);
}
System.out.println("main... 主线程结束...");
}
}
执行结果:
匿名内部类的方式
System.out.println("-----多线程创建开始-----");
new Thread() {
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("线程 -- " + Thread.currentThread().getName() + "-->" + i);
}
};
}.start();
System.out.println("-----多线程创建结束-----");
代码如下：
class ThreadDemo02 implements Runnable {
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(" 子 i:" + i);
}
}
}
// 1.实现runable接口，重写run方法
public class T002_CreateWithRunnable {
public static void main(String[] args) {
System.out.println("main... 主线程开始...");
// 创建线程
ThreadDemo02 threadDemo02 = new ThreadDemo02();
/*
* 这里 用了Thread的另一个构造方法，
* 该构造方法可以传入一个Runnable的实现类
* 而我们查看Thread的源码可以得知，Thread类 原本就实现了Runnable
* 所里也可以传入一个Thread的对象，这样就可以把一个Thread对象中的run()
* 方法交由其他的线程进行调用
*/
Thread t1= new Thread(threadDemo02);
// 启动线程
t1.start();
for (int i = 0; i <10; i++) {
System.out.println("main..i:"+i);
}
System.out.println("main... 主线程结束...");
}
}
匿名内部类的方式
System.out.println("-----多线程创建开始-----");
Thread thread = new Thread(new Runnable() {
public void run() {
for (int i = 0; i< 10; i++) {
System.out.println("i:" + i);
}
}
}).start();
System.out.println("-----多线程创建结束-----");
/**
*
* Callbale接口 可以又返回值，可以抛出异常，
* 而Runnable接口 中的run方法没有返回值，异常只能捕获
*
* @author hao
*
*/
public class T002_CreateWithCallable {
public static void main(String[] args) throws InterruptedException, ExecutionException {
MyCallable mc = new MyCallable();
FutureTask<Integer> ft = new FutureTask<Integer>(mc);
Thread thread = new Thread(ft);
thread.start();
System.out.println(ft.get());
}
}
class MyCallable implements Callable<Integer> {
public Integer call() throws Exception {
return 124;
}
}
示例
/*
* 什么是守护线程? 守护线程 进程线程(主线程挂了) 守护线程也会被自动销毁.
* 该示例中我们手动将子线程设置为守护线程，
* 当其他线程(该例中只有主线程)停止时守护线程也会终止
*/
public class DaemonThread {
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
try {
Thread.sleep(100);
} catch (Exception e) {
// TODO: handle exception
}
System.out.println("我是子线程...");
}
}
});
thread.setDaemon(true);
thread.start();
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(100);
} catch (Exception e) {
}
System.out.println("我是主线程");
}
System.out.println("主线程执行完毕!");
}
}
运行结果
示例代码
/**
* yield方法的作用是放弃当前的CPU资源，
* 将它让给其他的任务去占用CPU执行时间，
* 但是放弃的时间不确定，有可能刚刚放弃，马上又获得CPU时间片
* @author hao
*
*/
public class T009_Yield {
public static void main(String[] args) {
YeildTestThread t1 = new YeildTestThread();
t1.start();
}
}
class YeildTestThread extends Thread{
@Override
public void run() {
super.run();
long beginTime = System.currentTimeMillis();
int count =0;
for(int i =0;i<5000000;i++) {
//Thread.yield();
count = count +(i+1);
}
long endTime = System.currentTimeMillis();
System.out.println("用时："+(endTime-beginTime)+"毫秒！");
}
}
执行结果
注释掉 Thread.yield(); 和没注释掉是的执行时间不同。
代码示例
//创建一个线程，子线程执行完毕后，主线程才能执行。
public class T010_Join {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程,i:" + i);
}
}
});
t1.start();
// 当前线程释放资格权，等t1执行完毕之后，才会继续进行执行。
t1.join();
for (int i = 0; i < 5; i++) {
System.out.println("main线程,i:" + i);
}
}
}
执行结果
应用场景
有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行代码如下：
public class JoinThreadDemo02 {
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("t1,i:" + i);
}
}
});
Thread t2 = new Thread(new Runnable() {
public void run() {
try {
t1.join();
} catch (Exception e) {
}
for (int i = 0; i < 20; i++) {
System.out.println("t2,i:" + i);
}
}
});
Thread t3 = new Thread(new Runnable() {
public void run() {
try {
t2.join();
} catch (Exception e) {
}
for (int i = 0; i < 20; i++) {
System.out.println("t3,i:" + i);
}
}
});
t1.start();
t2.start();
t3.start();
}
}
public class T011_Priority {
public static void main(String[] args) {
PrioritytThread prioritytThread = new PrioritytThread();
Thread t1 = new Thread(prioritytThread);
Thread t2 = new Thread(prioritytThread);
t1.start();
// 注意设置了优先级， 不代表每次都一定会被执行。 只是CPU调度会有限分配
t1.setPriority(10);
t2.start();
}
}
class PrioritytThread implements Runnable {
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().toString() + "---i:" + i);
}
}
}
调用interrupt()方法后线程并没有马上停止，仅仅是在当前线程中打了一个停止的标记，并不是真正的停止线程。
源码如下
public static boolean interrupted() {
return currentThread().isInterrupted(true);
}
public boolean isInterrupted() {
return isInterrupted(false);
}
/**
* Tests if some Thread has been interrupted.
* The interrupted state is reset or not
* based on the value of ClearInterrupted that is passed.
*
* 判断某些线程是否已经中断。
* 根据传入的ClearInterrupted值来决定是否要重置中断的状态
*/
private native boolean isInterrupted(boolean ClearInterrupted);
/**
* 利用抛出异常的方式来终止线程
* @author hao
*
*/
public class Test_ExceptionInterrupt {
public static void main(String[] args) {
try {
ExcepThread t = new ExcepThread();
t.start();
Thread.sleep(2000);
t.interrupt();
} catch (InterruptedException e) {
System.out.println("main catch");
e.printStackTrace();
}
System.out.println("end！");
}
}
class ExcepThread extends Thread{
@Override
public void run() {
this.stop();
try {
for(int i=0;i<500000;i++) {
if(Thread.interrupted()) {
System.out.println("已经是停止状态了，我要退出了!");
// break;
throw new InterruptedException();
}
System.out.println("i "+(i+1));
}
System.out.println("我被输出了 。线程并未停止! 只是for循环被中断了");
} catch (InterruptedException e) {
System.out.println("catch t ");
e.printStackTrace();
}
}
}
一个未捕获的异常终止了run方法而使线程猝死。
为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法。如果是可运行或被阻塞，这个方法返回true； 如果线程仍旧是new状态且不是可运行的， 或者线程死亡了，则返回false.
标签：就会 toc 选中 线程状态 优先级 nts 工作 性能 多任务
原文地址：https://www.cnblogs.com/haoworld/p/java-bing-fa-ji-chu.html
