Java多线程

程序 ：一组命令的集合，完成指定功能，静态概念

进程 ：正在运行的程序，是一个动态概念

线程 ：进程的一个执行分支

并发：一个cpu同时执行多个任务

并行： 多个cpu同时执行多个任务

线程创建

两种方式,继承Thread类，实现Runnable接口。

public static void main(String[] args) {
		Thread t=new Thr();
		Thread thr=new Thread(new ThrR());
		//启动线程
		thr.start();
		t.start();
	}
class Thr extends Thread{
	@Override
	public void run() {
		System.out.println("创建线程方式一");
	}	
}
class ThrR implements Runnable{
	@Override
	public void run() {
		//要完成的任务
		System.out.println("创建线程方式二");
	}
	
}

优先级与常用方法

最大优先级为10，最小为1，默认为5

setPriority()设置线程优先级，要在start()方法之前使用，getPriority()获取线程优先级；getName()获取线程名字，setName()设置线程名字，不设置默认依次Thread-0，Thread-1...

静态方法 -- currentThread()，sleep(),在哪个线程调用，就获取这个线程对象或让这个线程睡眠

        //main的线程名字为main，currentThread()为静态方法，获取当前线程对象，在哪个线程中就获取那个线程对象
        System.out.println(Thread.currentThread().getName());
        Thread thr=new Thread(new ThrR());
        //设置优先级需要在启动之前，线程会继承父类的优先级，默认5
        thr.setPriority(9);
        //启动线程
        thr.start();

生命周期

新建状态（一个线程对象被分配并创建时），

就绪状态（调用start方法后，等待时间切片，可以运行，但是没有分到cpu的资源），

运行状态（线程被调度并获得cpu资源时），

阻塞状态（在特殊情况时，被认为挂起等，让出cpu终止自己的执行），

死亡状态（完成所有任务或提前被强制性终止或出现异常时）

线程控制方法

join()方法合并线程，将某线程与当前线程合并，等这个线程执行结束，再执行当前线程；

isAlive()方法判断线程是否结束；

yield()方法让出cpu，当前线程进入就绪状态等待调度；

stop()方法，终止线程执行，不推荐使用会导致死锁，可使用标识符解决

public class ThreadControl {
	public static void main(String[] args) throws InterruptedException {
		Thread thr = new Thread(new Sui());
//		Thread thr1 = new Thread(new Sui());
		thr.start();
//      执行完thr线程之后，主线程继续执行
//		thr.join();
//		thr1.start();
		for (int i = 0; i < 8; i++) {
			Thread.yield();
			System.out.println("zhuxiancheng");
		}
		
		Thread.sleep(2000);
		new Sui().flag=true;
//		thr.stop();
	}
}

class Sui implements Runnable {
	boolean flag=false;
	@Override
	public void run() {
		for (int i = 0; i < 5; i++) {
			if(flag) {
				System.out.println("停止运行");
			}
			System.out.println("suibianba");
		}
	}
}

线程同步

--需要用到锁机制

方法锁 -- synchronized修饰的静态方法叫类锁，synchronized修饰的成员方法叫对象锁

当某个线程访问某个对象中的synchronized修饰的方法时，此对象的所有synchronized修饰的方法都被锁住，都不能被访问操作，语句块锁同理，但语句块锁的效率比方法锁相对高一点

同步机制，效率相对较低，线程需要排队执行，但安全性较高，一致性有所保障

当多个线程同时操作同一个数据时，可能会导致数据的不一致，为了保护数据的一致性，需要同步执行，多线程同一时间对同一数据进行修改操作时需要同步数据。

三种，方法锁，语句块锁，Lock9（jdk5.0提供的线程同步机制）

//方法锁

    public synchronized void run() {
        s.getMoney();
    }

//语句块锁，相较于方法锁来说效率高        

synchronized (this) {
            s.setMoney();
        }

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;  

//Lock锁需要手动加锁与释放锁

 Lock lock=new ReentrantLock();
    
    public void setMoney() {
        lock.lock();
        System.out.println("方法锁存钱");
        lock.unlock();
    }

Lock锁与synchronized修饰的方法锁或语句块锁的区别：Lock锁需要显示的开启关闭锁，而synchronized锁是隐式锁，自动进行开启关闭锁；Lock锁只有代码块锁，synchronized锁除了代码块锁还有方法锁；Lock锁扩展性较好，花费较少的时间进行资源调度，性能相对较好

定时器任务

 定时器任务，到达时间后由这个线程来完成任

public class TimerTask_ {
	public static void main(String[] args) {
		Timer timer=new Timer();
		//第一个参数任务对象，2：开始时间，3：执行间隔时长
//		timer.schedule(new Task1(), new Date(System.currentTimeMillis()+1000), 5000);
		//第一个参数任务对象，2：多久之后开始，3：执行间隔时长
//		timer.schedule(new Task1(), 1000, 100);
	}
}
class Task1 extends TimerTask{

	@Override
	public void run() {
		System.out.println("任务");
	}
}