多线程（一）

目录

 

进程

守护线程

非守护线程

join()

yield()

多线程运行状态

线程的几种创建方式

---

进程

      进程就是正在运行的程序，是线程的集合。每一个线程是进程中的一条执行路径。

多线程应用场景：分布式job，文件上传

守护线程

           和main相关，与主线程一起销毁，

           使用setDaemon(true)方法设置为守护线程

           eg：gc线程

非守护线程

               是主线程创建的，用户的线程，如果主线程停掉不会影响用户线程

join()

join作用是让其他线程变为等待,   

// 让其他线程变为等待，直到当前t1线程执行完毕，才释放。
Thread.join();

yield()

Thread.yield()方法的作用：暂停当前正在执行的线程,让当前正在运行的线程回到可运行状态，并执行其他线程。（可能没有效果）

多线程运行状态

 

新建：new Thread（）

就绪：等待cpu调度当start()方法返回后，线程就处于就绪状态

运行：run

结束：执行完毕或，stop()

阻塞状态：sleep或wait操作之后，进入阻塞状态。阻塞恢复之后进入就绪状态

线程的几种创建方式

1. 继承Thread
2. 实现Runnable接口
3. 匿名内部类
4. callable

package com.www.learn.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class Thread01 {
	/**
	 * 创建线程方式 1.继承Thread 2.实现Runnable 3.匿名内部类 4.callable
	 */
	public static void main(String[] args) {
		CreateThread1 ct1 = new CreateThread1();
        ct1.start();

		CreateThread2 ct2 = new CreateThread2();
		Thread t = new Thread(ct2, "Runnable线程");
		t.start();

		/*
		 * //什么是匿名内部类 
         * Parent p =new Parent() {
		 *     @Override 
         *     public void add() { 
         *       System.out.println("使用自定义内部类"); 
         *    } 
         * }; 
         * p.add();
		 */

        //创建线程方式3，匿名内部类
		// 3.匿名内部类
		Thread tr = new Thread(new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 100; i++) {
					System.out.println("run,tri:" + i);
				}
			}
		});
		tr.start();
		
		//4.callable
		FutureTask<String> ft = new FutureTask<>(new CreateThread4());
        new Thread(ft).start();
        
        //join
        //保证ct1线程在执行完才执行主线程
        try {
			ct1.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		// 注意启动线程是使用start()方法
		// 开启多线程后代码不会从上往下执行
		for (int i = 0; i < 100; i++) {
			System.out.println("主线程id：" + Thread.currentThread().getId() + " name:" + Thread.currentThread().getName());
			System.out.println("main,i:" + i);
			CreateThread1 ct12 = new CreateThread1();
			ct12.start();
		}

		// 获取当前线程
		// Thread.currentThread();
	}
}

/**
 * 创建线程方式1，继承Thread类
 */
class CreateThread1 extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("线程id" + getId() + "子线程run,ti:" + i + " name:" + getName());
			if (i == 5) {
				// 不推荐使用
				stop();
			}
		}
	}
}

/**
 * 创建线程方式2，实现Runnable 接口
 */
class CreateThread2 implements Runnable {
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			// 需使用Thread.currentThread()
			System.out.println("线程id" + Thread.currentThread().getId() + "子线程run,ri:" + i + " name:"
					+ Thread.currentThread().getName());
		}
	}
}

/**
 * 创建线程方式4，实现Runnable 接口
 */
class CreateThread4 implements Callable<String>{
	@Override
	public String call() throws Exception {
		System.out.println("Callable");
		return null;
	}
}

/**
 * 匿名内部类
 */
abstract class Parent {
	public abstract void add();
}