ThreadTest01.java:
/*
分析以下程序有几个线程？
以下程序只有一个线程，就是主线程.
main,m1,m2,m3这四个方法在同一个栈空间中。
没有启动其他任何线程。
*/
public class ThreadTest01 {
public static void main(String[] args){
m1();
}
public static void m1(){
m2();
}
public static void m2(){
m3();
}
public static void m3(){
System.out.println("m3....");
}
}
ThreadTest02.java：
/*
在java语言中实现多线程的第一种方式：
第一步：继承java.lang.Thread;
第二步：重写run方法.
三个知识点：
如何定义线程？
如何创建线程？
如何启动线程？
*/
public class ThreadTest02 {
public static void main(String[] args){
//创建线程
Thread t = new Processor();
//启动
t.start();//这行代码执行瞬间结束，告诉JVM再分配一个栈内存给t线程
//run不需要程序员手动调用，系统线程启动之后自动调用run方法
//t.run();//这是普通方法调用，这样做程序只有一个线程，run方法结束之后，下面的程序才能继续执行。
//这行代码在主线程中运行
for(int i = 0;i<30;i++){
System.out.println("main----->"+i);
}
//有了多线程之后，main方法结束只是主线程栈中没有方法栈帧了
//但是其他线程或者其他栈中还有栈帧
//main方法结束 程序可能仍在运行
}
}
//定义一个线程
class Processor extends Thread{
//重写run方法
public void run(){
for(int i=0;i<15;i++){
System.out.println("run---->"+i);
}
}
}
ThreadTest03.java:
/*
java中实现线程的第二种方式：
第一步：写一个类实现java.lang.Runnable;接口
第二步：实现run方法.
*/
public class ThreadTest03
{
public static void main(String[] args){
//创建线程
Thread t = new Thread(new Processor1());
//启动
t.start();
}
}
//这种方式是推荐的。因为一个类实现接口之外保留了类的继承。
class Processor1 implements Runnable
{
public void run(){
for(int i=0;i<10;i++){
System.out.println("run-->"+i);
}
}
}
ThreadTest04.java:
/*
三个方法：
1.获取当前线程对象Thread.currentThread();
2.给线程起名 t.setName("t1");
3.获取线程的名字 t.getName();
*/
public class ThreadTest04 {
public static void main(String[] args){
//如何获取当前线程对象?
Thread t = Thread.currentThread();
//获取线程到的名字
System.out.println(t.getName());
Thread t1 = new Thread(new Processor2());
//给线程起名
t1.setName("t1");
t1.start();
Thread t2 = new Thread(new Processor2());
t2.setName("t2");
t2.start();
}
}
class Processor2 implements Runnable{
public void run(){
Thread t = Thread.currentThread();//t保存的内存地址指向的线程是t1对象
System.out.println(t.getName());//thread-0 Thread-1
}
}
ThreadTest05.java:
/*
线程优先级高的获取的CPU时间片相对多一些。
优先级：1-10
最低 1
最高 10
默认 5
*/
public class ThreadTest05 {
public static void main(String[] args){
System.out.println(Thread.MAX_PRIORITY);//10
System.out.println(Thread.MIN_PRIORITY);//1
System.out.println(Thread.NORM_PRIORITY);//5
Thread t1 = new Processor3();
t1.setName("t1");
Thread t2 = new Processor3();
t2.setName("t2");
System.out.println(t1.getPriority());//5
System.out.println(t2.getPriority());//5
//设置优先级
t1.setPriority(5);
t2.setPriority(6);
//启动线程
t1.start();
t2.start();
}
}
class Processor3 extends Thread{
public void run(){
for(int i=0;i<50;i++){
System.out.println(Thread.currentThread().getName()+"---->"+i);
}
}
}
ThreadTest06.java:
/*
1.Thread.sleep(毫秒);
2.sleep方法是一个静态方法.
3.该方法的作用：阻塞当前线程.腾出CPU，让给其他线程。
*/
public class ThreadTest06 {
public static void main(String[] args)throws InterruptedException{
Thread t1 = new Processor4();
t1.setName("t1");
t1.start();
//阻塞主线程
for(int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+"---->"+i);
Thread.sleep(500);
}
}
}
class Processor4 extends Thread{
//Thread中的run方法不抛出异常，所以重写run方法之后，在run方法的声明位置上不能使用throws
//所以run方法中的异常只能try...catch...
public void run(){
for(int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+"-------->"+i);
try{
Thread.sleep(1000);//让当前程序阻塞1s
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
ThreadTest07.java:
//面试题
public class ThreadTest07 {
public static void main(String[] args)throws Exception{
//创建线程
Thread t = new Processor5();
t.setName("t");
//启动线程
t.start();
//休眠线程
t.sleep(5000);//等同于Thread.sleep(5000);阻塞的还是当前线程,和t线程无关
System.out.println("HelloWorld!");
A a = null;
a.m1();
}
}
class Processor5 extends Thread{
public void run(){
for(int i=0;i<200;i++){
System.out.println(Thread.currentThread().getName()+"--->"+i);
}
}
}
class A{
public static void m1(){
}
}
ThreadTest08.java:
/*
某线程正在休眠，如果打断它的休眠.
以下方式依靠的是异常处理机制。
*/
public class ThreadTest08 {
public static void main(String[] args)throws Exception{
//需求：启动线程 5s后打断线程的休眠
Thread t = new Thread(new Processor6());
//起名
t.setName("t");
//启动
t.start();
//5s之后
t.sleep(5000);
//打断t的休眠
t.interrupt();
}
}
class Processor6 implements Runnable{
public void run(){
try{
Thread.sleep(1000000000L);
System.out.println("HelloWorld!");
}catch(InterruptedException e){
// e.printStackTrace();
}
for(int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+"--->"+i);
}
}
}
ThreadTest09.java:
/*
如何正确的更好的终止一个正在执行的线程.
需求：线程启动5S之后终止。
*/
public class ThreadTest09 {
public static void main(String[] args)throws Exception{
Processor7 p = new Processor7();
Thread t = new Thread(p);
t.setName("t");
t.start();
//5s之后终止
Thread.sleep(5000);
//终止
p.run = false;
}
}
class Processor7 implements Runnable{
boolean run = true;
public void run(){
for(int i=0;i<10;i++){
if(run){
try{Thread.sleep(1000);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"--->"+i);
}else{
return;
}
}
}
}
ThreadTest10.java:
/*
Thread.yield();
1.该方法是一个静态方法.
2.作用：给同一个优先级的线程让位。但是让位时间不固定。
3.和sleep方法相同，就是yield时间不固定。
*/
public class ThreadTest10 {
public static void main(String[] args){
Thread t = new Processor8();
t.setName("t");
t.start();
//主线程中
for(int i=0;i<100;i++){
System.out.println(Thread.currentThread().getName()+"--->"+i);
}
}
}
class Processor8 extends Thread{
public void run(){
for(int i=0;i<100;i++){
System.out.println(Thread.currentThread().getName()+"--->"+i);
if(i%20==0){
Thread.yield();
}
}
}
}
