Java-多线程（1）

进程

进程概述：进程就是正在运行的程序，是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。
多进程的意义：如今的操作系统基本都是多进程操作系统，能在同一时间段执行多个任务。这能说明这多个任务是同时进行的吗？并不能，对于单核计算机而言，CPU在某个时间点上只能执行一个任务，我们所感觉到的执行多个任务，只不过是计算机在进程中高速切换，这就说明了多进程的意义不是提高执行速度，而是提高CPU的利用率。

线程

线程概述：在进程的内部会执行多个任务，这多个任务就是线程。线程是程序使用CPU的基本单位。
多线程的意义：程序在运行期间，任务之间在抢占CPU时间片，CPU在多线程中的运行时间要比单线程多，从而也就提高了程序的使用率，但是多线程中哪个线程能够抢占上资源，这都是不固定的。

多线程

多线程的实现方式：定义一个类，继承Thread类，启动线程。
我们启动线程使用不是run方法，而是start方法。该线程开始执行Java 虚拟机调用该线程的 run 方法。run方法中一般放比较耗时的代码。 

//MyThread类
public class MyThread extends Thread {
@Override
public void run() {
super.run();
for(int i=0;i<10;i++){
System.out.println(this.getName()+"->"+i);
}
}
}

//Test类
public class Test1 {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.setName("周杰伦");
MyThread myThread1 = new MyThread();
myThread1.setName("彭于晏");
myThread.start();//开启线程
myThread1.start();
}
}

Thread类的获取和设置方式：

        public final String getName()//获取线程名称
public final void setName(String name)//设置线程名称
        或者通过构造设置名称
//Thread2类
public class MyThread2 extends Thread{
public MyThread2(String s) {
super(s);
}
@Override
public void run() {
super.run();
for(int i=0;i<10;i++){
System.out.println(this.getName()+"->"+i);
}
}
}

public class Test2 {
public static void main(String[] args) {
MyThread2 my1 = new MyThread2("1号");
MyThread2 my2 = new MyThread2("2号");
MyThread2 my3 = new MyThread2("3号");
my1.start();
my2.start();
my3.start();
}
}

线程的两种调度方式
        a.分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片。
        b.抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些。 Java使用的是抢占式调度模型。

可以给线程设置优先级，但是会发现有时候即使设置了优先级，线程也不会按照优先级高的执行，是因为线程仅仅是将CPU执行的概率增大了，但是线程仍具有随机性。
        public final int getPriority() //获取线程的优先级
        public final void setPriority(int newPriority)//设置线程的优先级public class Test2 {
public static void main(String[] args) {
MyThread2 my1 = new MyThread2("周杰伦");
MyThread2 my2 = new MyThread2("彭于晏");
MyThread2 my3 = new MyThread2("胡歌");
//设置优先级
//my1.setPriority(0);java.lang.IllegalArgumentException 参数异常
my1.setPriority(5);
my2.setPriority(10);
my3.setPriority(8);
int maxPriority = Thread.MAX_PRIORITY;
int minPriority = Thread.MIN_PRIORITY;
//线程的优先级是1-10
System.out.println(maxPriority);//10
System.out.println(minPriority);//1

//获取优先级
int priority = my1.getPriority();
int priority1 = my2.getPriority();
int priority2 = my3.getPriority();
System.out.println("-----------");
System.out.println(priority);//5
System.out.println(priority1);//10
System.out.println(priority2);//8

my1.start();
my2.start();
my3.start();
}
}Thread休眠： public static void sleep(long millis)
加入Thread：等待该线程执行完毕了以后，其他线程才能再次执行，在线程启动之后,在调用方法。
        public final void join()//MyThread类
public class MyThread extends Thread{
public MyThread(String name) {
super(name);
}

@Override
public void run() {
super.run();
for(int i=0;i<10;i++){
System.out.println(this.getName()+"->"+i);
}
}
}

//Test类
public class Test1 {
public static void main(String[] args) {
//加入线程
MyThread my1 = new MyThread("杨幂");
MyThread my2 = new MyThread("王菲");
MyThread my3 = new MyThread("林心如");
my2.start();//让my2先执行完，my1和my2之后执行
try {
my2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
my1.start();
my3.start();
}
}

礼让线程：public static void yield() 暂停当前正在执行的线程对象，并执行其他线程。·
守护线程：将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。
        public final void setDaemon(boolean on):public class MyThread3{
public static void main(String[] args) {

String name = Thread.currentThread().getName();
System.out.println(name);//主线程名为main
ThisThread th1 = new ThisThread();
ThisThread th2 = new ThisThread();
th1.setName("小明");
th2.setName("韩梅梅");
th1.setDaemon(true);
th2.setDaemon(true);
//守护线程必须在启动线程前执行
th1.start();
th2.start();

}
}

class ThisThread extends Thread{
@Override
public void run() {
super.run();
for(int i=0;i<10;i++){
System.out.println(this.getName()+"->"+i);
}
}
}中断线程：public final void stop() 停止线程的运行
                        public void interrupt():中断线程