线程610

1线程的创建一

```java
/*
 * 创建线程的方式1   继承Thread类（线程类）
 */
public class Thread01 extends Thread{
	
	public Thread01() {
		
	}
	public Thread01(String name) {
		// TODO Auto-generated constructor stub
		super(name);
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("开始为我干活");
		for (int i = 0; i < 10; i++) {
			try {
				Thread.sleep(1000,999999);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+i);
		}
	}
	public static void main(String[] args) {
		//创建线程对象
		Thread01 thread01=new Thread01();
		//启动当前线程呃
		thread01.start();
	}

线程的创建二

public class Thread02 implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("Runnable 接口实现方法");
		for (int i = 0; i < 10; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+i);
		}
	}
	public static void main(String[] args) {
		Thread02 thread02 =new Thread02();
		//使用Thread 线程的构造方法 传入Runnable的子类  创建线程对象
		Thread thread=new Thread(thread02);
		//启动当前的线程
		thread.start();
	}

匿名内部类创建线程

Thread th1=new Thread(){
			@Override
			public void run() {
				
				for (int i = 0; i < 100; i++) {
					System.out.println(i);
				}
			}
			
		};

Runnable runnable =new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for (int i = 0; i < 100; i++) {
					System.out.println("runnable"+i);
				}
			}
		};

```java
//创建Runnable线程对象
		Thread th2=new Thread(runnable);
		//两个线程之间是独立的 
		th1.start();
		th2.start();

public static void main(String[] args) {
		Thread th1=new Thread(){
			@Override
			public void run() {
				
				for (int i = 0; i < 100; i++) {
					System.out.println(i);
				}
			}
			
		};
		
		Runnable runnable =new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for (int i = 0; i < 10; i++) {
					System.out.println("runnable"+i);
				}
			}
		};
		//创建Runnable线程对象
		Thread th2=new Thread(runnable);
		
		//isDasemon 判定是否是后台线程  默认是前台线程
		System.out.println(th1.isDaemon());
		
		th1.setName("前台线程");
		th2.setName("后台线程");
		
		//th2设置为守护线程   (后台线程)
		th2.setDaemon(true);
		
		/*
		 * 前台线程结束 后台线程一定结束 
		 * 后台线程结束 前台线程不会结束
		 *
		 */
		
		th1.start();
		th2.start();
		
	}

• 前台线程结束 后台线程一定结束
  后台线程结束 前台线程不会结束

线程方法

sleep和yield都是Thread类的静态方法，都会使当前处于运行状态的线程放弃CPU，但两者的区别在于：
i. sleep给其它线程运行的机会，但不考虑其它线程的优先级；但yield只会让位给相同或更高优先级的线程；
ii. 创建–就绪–运行–阻塞-死亡
iii. 当线程执行了sleep方法后，将转到阻塞状态，而执行了yield方法之后，则转到就绪状态（）；
iv. sleep方法有可能抛出异常，而yield则没有；
v. 在一般情况下，我们更建议使用sleep方法。
3、 join方法用于等待其它线程结束，当前运行的线程可以调用另一线程的join方法，当前运行线程将转到阻塞状态，直至另一线程执行结束，它才会恢复运行。

多线程:
一个应用程序下,有多个小任务同时执行
每一个任务就是一个线程
各个线程可以互不干扰独立运行,也可以相互通讯协同执行

进程和线程

一个进程其实就是一个应用程序,一个进程包含多个线程,线程之间的切换效率要高于进程之间的切换,多线程的应用程序更能有效利用cpu

多线程执行的原理:
多个线程交替执行(时间片的轮换) 每个线程执行的时间由虚拟随机分配,无法改变

java如何实现多线程
Thread - 线程类

1:继承Thread类,重写run方法
run方法中的内容,就是线程要执行的内容

线程的生命周期:

1: 准备 实例化线程类
2: 就绪 实例化完毕就处于就绪状态
3: 启动 调用线程对象的start方法,(使线程进入可执行状态,等待虚拟机分配运行权限)
4: 运行 run执行
5: 死亡 run方法结束后,线程处于死亡状态,已经死亡的线程,不支持重新start

2:Runnable接口:
实现runnable实现run方法

线程的同步:
线程的不安全: 多个线程同时操作同一块地址空间

1:同步块

synchronized (锁对象)
{
需要同步的代码段;

}

2:同步方法:(默认锁this)

访问控制 synchronized 返回值 方法名(参数) 定义抛出异常{
同步代码;
}

线程的阻塞:
Thread.sleep(毫秒);//让当前的线程进入睡眠状态,经过设置的毫秒数后会自动恢复
线程对象.join();//阻塞线程,不会自动恢复,需要其他线程调用这个对象的interrupt()方法抛出InterruptedException来结束阻塞状态

线程的等待和唤醒:

wait
notify
notifyAll

以上方法都是Object的方法:
必须使用在同步代码段中
锁对象.wait() – 当前线程等待,解开对象锁
锁对象.notify() – 唤醒最先进入到等待队列里的线程 , 对象加锁
锁对象.notifyAll() – 唤醒等待队列中的所有线程