java-线程

1.并发：在同一时刻，有多个指令在单个cpu上交替进行
2.并行，在同一时刻，有多个指令在多个cpu上同时执行

多线程的实现方式：
1.继承Thread 类的方式进行实现
2.实现Runnable 接口的方式进行实现
3.利用Callable 接口和 Future 接口方式实现

1.继承Thread 类的方式进行实现
	1.自己定义一个类继承Thread
	2.重写run方法
	3.创建子类的对象，并启动线程
public class MyThread extends Thread{
	@override
	public void run(){
		System.out.println(getName()+"asdasdasda");
	}
}
MyThread t1 = new MyThread();
t1.setName("线程一");
t1.start();

2.实现Runnable 接口的方式进行实现
	1.自己定义一个类实现Runnable接口
	2.重写里面的run方法
	3.创建自己的类的对象
	4.创建一个Thread类的对象，并开启线程
	
public class MyRun iplements Runnable{
	@override
	public void run(){
		Thread t = Thread.currentThread();
		System.out.println(t.getName()+"asdasdasda");
	}
}
MyRun mr= new MyRun();
Thread t1 = new Thread(mr);
t1.setName("线程一");
t1.start();

3.利用Callable 接口和 Future 接口方式实现
	特点：可以获取到多线程运行的结果
	1.创建一个类MyCallable 实现 Callable接口
	2.重写call (有返回值，表示多线程运行的结果)
	3.创建MyCallable 的对象，（表示多线程要执行的任务）
	4.创建FutureTask的对象（作用管理多线程运行的结果）
	5.创建Thread类的对象  ，并启动线程

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum = sum +i;
        }       
        return sum;
    }
}

   MyCallable mc = new MyCallable();
   FutureTask<Integer> ft = new FutureTask<>(mc);
   Thread t1 = new Thread(ft);
   t1.start();
   Integer result = ft.get();
   System.out.println(result);

常见的成员方法
String getName() 返回此线程的名称
void setName(String name) 设置线程的名字
static Thread currentThread() 获取当前线程的对象
static void sleep(long time) 让线程休眠指定的时间 单位为毫秒
setpriority(int newPriority) 设置线程优先级 1-10 10最高
final void SetDaemon(boolean on) 设置为守护线程
public static void yield() 出让线程/礼让线程
public static void join() 插入线程/插队线程

同步代码快：把操作共享数据的代码锁起来
特点：锁默认打开，有一个线程进去了，锁自动关闭
里面的代码全部执行完毕，线程出来，锁自动的打开

static  类的所有的对象共享

synchronized（锁）{
	操作共享数据的代码
}

同步方法：就是把synchronized关键字加到方法上
特点：同步方法是锁住方法里面所有的代码
锁的对象不能自己指定 非静态：this
静态：当前类的字节码文件对象 Thread.class

格式：修饰符 synchronized 返回值类型 方法名(方法参数){}

public class MyRunnable implements Runnable{
		
		int ticket = 0;
		@override
		publicc void run(){
			//循环
			while(true){          
				//同步代码块（同步方法）
				synchronizedd(MyRunnable.class（锁对象）){
					//判断共享数据是否到末尾，如果到末尾
					if(ticket == 100){
					break;
					}else{
						//	判断共享数据是否到末尾，如果没有到末尾
						ticket++;
					  System.out.println(Thread.currentThread().getName()+"在买票")
}	
}					
}
			
}
	}

MyRunnablemr= new MyRunnable();
Thread t1 = new Thread(mr);
Thread t2 = new Thread(mr);
t1.setName("线程一");
t2.setName("线程2");
t1.start();
t2.start();

阻塞队列实现等待唤醒机制
线程的状态：
新建状态 --------- 创建线程对象
就绪状态 ----------start 方法
阻塞状态 ----------无法获得锁对象
等待状态----------wait 方法
计时状态----------sleep方法
结束状态----------全部代码运行完毕

线程池：

创建线程池：Executors
1.获取线程池对象
ExecutorService pool1 = Executors.newCachedThreadPool();
ExecutorService pool1 = Executors.newFixedThreadPool(3); 指定线程池

2.提交任务
pool1.submit(new MyRunnable());
3.销毁线程池
pool1。shutdown();