JavaSE复习——Thread

1、概述

	进程：是正在运行的程序
		  是系统进行资源分配和调用的独立单位
		  ​每一个进程都有它自己的内存空间和系统资源
	线程：是进程中的单个顺序控制流，是一条执行路径
  ​		 单线程：一个进程如果只有一条执行路径，则称为单线程程序
  ​		 多线程：一个进程如果有多条执行路径，则称为多线程程序

2、实现多线程的三种方式：

1.继承Thread类，重写run方法
2.实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target
3.通过Callable和FutureTask创建线程  

3、实现多线程的方式一

- 实现步骤
  - 定义一个类MyThread继承Thread类
  - 在MyThread类中重写run()方法
  - 创建MyThread类的对象
  - 启动线程

//定义一个类MyThread继承Thread类
public class MyThread extends Thread {

    //在MyThread类中重写run()方法
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"正在执行");
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
    	//创建MyThread类的对象
        MyThread mt = new MyThread();
        //设置线程name
        mt.setName("线程一");
        //开启线程
        mt.start();
    }
}

4、实现多线程的方式二

- 实现步骤
  - 定义一个类MyRunnable实现Runnable接口
  - 在MyRunnable类中重写run()方法
  - 创建MyRunnable类的对象
  - 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
  - 启动线程

//定义一个类MyRunnable实现Runnable接口
public class MyRunnable implements Runnable {
    //在MyRunnable类中重写run()方法
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

public class MyRunableDemo {
    public static void main(String[] args) {
        //创建MyRunnable类的对象
        MyRunnable my = new MyRunnable();

        //创建Thread类的对象，把MyRunnable对象作为构造方法的参数
        //第一种（不赋值name） Thread(Runnable target)
        //        Thread t1 = new Thread(my);
        //        Thread t2 = new Thread(my);
        //第二种（赋值name） Thread(Runnable target, String name)
        Thread t1 = new Thread(my,"张三");
        Thread t2 = new Thread(my,"李四");

        //启动线程
        t1.start();
        t2.start();
    }
}

5、实现多线程的方式三：

	创建Callable接口的实现类 ，并实现Call方法 
	创建Callable实现类的实现，使用FutureTask类包装Callable对象，该FutureTask对象封装了Callable对象的Call方法的返回值 
	使用FutureTask对象作为Thread对象的target创建并启动线程 
	调用FutureTask对象的get()来获取子线程执行结束的返回值

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class CallableDemo {

    static class Tickets<Object> implements Callable<Object>{

        //重写call方法
        @Override
        public Object call() throws Exception {

            System.out.println(Thread.currentThread().getName()+"：我是Callable接口");
            return null;
        }
    }

    public static void main(String[] args) {

        //创建Callable实现类的实现
        Callable<Object> oneCallable = new Tickets<Object>();
        //使用FutureTask类包装Callable对象
        FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);
        //使用FutureTask对象作为Thread对象的target创建并启动线程
        Thread t = new Thread(oneTask);
        //调用FutureTask对象的get()来获取子线程执行结束的返回值
        System.out.println(Thread.currentThread().getName());
        //启动线程
        t.start();

    }

}

6、Thread相关方法

	void run()   	
			在线程开启后，此方法将被调用执行            
  	void start()  	
  			使此线程开始执行，Java虚拟机会调用run方法() 
  	void  setName(String name)
  			将此线程的名称更改为等于参数name
  	String  getName()
  			返回此线程的名称
  	Thread  currentThread()
  			返回对当前正在执行的线程对象的引用


	final int getPriority()
			返回此线程的优先级
	final void setPriority(int newPriority)
			更改此线程的优先级


	static void sleep(long millis)
			使当前正在执行的线程停留（暂停执行）指定的毫秒数
	void join()
			等待这个线程死亡
	void setDaemon(boolean on)
			将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出
	

	Thread(Runnable target)
			分配一个新的Thread对象
	Thread(Runnable target, String name)
			分配一个新的Thread对象并赋值name

7、线程同步

	1、同步代码块
		同步代码块格式：

synchronized(任意对象) { 
	多条语句操作共享数据的代码 
}

		代码演示：

public class SellTicket implements Runnable {
    private int tickets = 100;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--; 
                }
            }
        }
    }
}

public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();

        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

2、Lock锁
	方法：
	ReentrantLock()
			创建一个ReentrantLock的实例
	void lock()
			获得锁
	void unlock()
			释放锁
	代码演示：

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

public class RunnableTest {

    public static class SelTickets implements Runnable {

        private int ticket = 100;
        private Lock lo = new ReentrantLock();

        @Override
        public void run() {
            while(true){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    lo.lock();
                    if (ticket > 0) {
                        System.out.println(Thread.currentThread().getName() + "正在出售第" + ticket + "张票");
                        ticket--;
                    }
                } finally {
                    lo.unlock();
                }
            }
        }
    }

    public static void main(String[] args) {
        SelTickets s1 = new SelTickets();
        Object obj=null;

        Thread ts1 = new Thread(s1, "窗口一");
        Thread ts2 = new Thread(s1, "窗口二");
        Thread ts3 = new Thread(s1, "窗口三");

        ts1.start();
        ts2.start();
        ts3.start();
    }
}

8、Object的方法

无需对象，直接使用
void wait() 		导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法 
void notify()     	唤醒正在等待对象监视器的单个线程  
void notifyAll() 	唤醒正在等待对象监视器的所有线程