Java基础学习之 线程初识

一线程和进程

一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

标准的单线程程序

  特点:程序由上至下依次执行.(一个程序执行完 才会执行另一个程序)

  好处:绝对安全,不牵扯操作共享数据;

  弊端:效率不高:

  开启了一个线程 相当于 开启了一个CPU 的执行路径(相对独立的)

  CPU在执行多个线程时时随机的,跟线程的优先级有关.

二创建一个线程

方法一: 通过继承 Thread 类本身；

package com.lanou4g;

import com.lanou4g.SubThread;

public class Demo01 {
	public static void main(String[] args) {
		//创建一个子线程
				//开启多个线程时,多个线程会同时执行 ,并且是独立的执行单元
		SubThread subThread = new SubThread();
		subThread.start();
		//再开一个子线程
		SubThread subThread1 = new SubThread();
		subThread1.start();
	}

}

class SubThread extends Thread{
	@Override
	public void run() {
		for (int i = 0; i <100; i++) {
			System.out.println(Thread.currentThread().getName() +"------" +i);
		}
	}
}

方法二:通过实现 Runnable 接口；

package com.lanou4g;


public class Demo02 {
	public static void main(String[] args) {
		RunableImpl runableImpl = new RunableImpl();
	    Thread thread = new Thread(runableImpl);
	    thread.start();
	}
   
			
			
			
}
class RunableImpl implements Runnable{

	@Override
	public void run() {
	for (int i = 0; i < 100; i++) {
		System.out.println(Thread.currentThread().getName()+"---"+i);
	 }
		
	}
	
}

匿名内部类的方法创建线程:

package com.lanou4g;

public class Demo03 {
	public static void main(String[] args) {
		//方式一(用Thrread子类的方式)
		Thread thread = new Thread() {
			@Override
			public void run() {
				System.out.println("我是子线程1的执行方法");
			}
		};
		thread.start();
		
		//方式二(用接口实现类的方式)
		
		Runnable runnable = new Runnable() {
			
			@Override
			public void run() {
				System.out.println("我是子线程2的执行方法");
				
			}
		};
		Thread thread2 = new Thread(runnable);
		thread2.start();
		
		//方式三
		new Thread(
				new Runnable() {
					
					@Override
					public void run() {
						System.out.println("我是子线程3的执行方法");	
						
					}
				}
				
				
				).start();
	}

}

线程的休眠: sleep()

package com.lanou4g;

public class Demo04 {
	public static void main(String[] args) {
		TestA testA = new TestA();
		testA.start();
	}
	

}


class TestA extends Thread{
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
		try {
			//休眠
			//父类中run方法没抛异常
			//子类只能try--catch 处理
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}	
		System.out.println(Thread.currentThread().getName()+"----"+i);	
		//打印结果每隔一秒出现一次	
			
		}
	}
}

一个线程的生命周期(线程的6中状态)

• 新建状态:

  使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

• 等待状态:

  当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

• 运行状态:

  如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

• 阻塞状态: 
• 运行状态中的线程执行 wait() 方法和 notifily()方法时 使线程进入等待状态。
  
• 休眠状态:
  

  一个线程执行了sleep（睡眠),在睡眠时间已到.能够自动醒来。
  

• 死亡状态:

  一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。