进程和线程：
进程可以看成一个个系统中运行的程序，而线程可以理解成是进程中独立运行的子任务。
优点：使用多线程后，可以在同一时间内运行更多不同种类的任务。
使用多线程：（代码的运行结果与代码执行顺序或调用顺序是无关的）
- 继承Thread类
先看Thread源码：
public class Thread implements Runnable
可以看出Thread类实现了Runnable接口，它们之间具有多态的关系。但这种方法的局限在于：不支持多继承
- 实现Runnable接口
如果创建的线程已经有一个父类了，这时就不能再继承Thread类了，于是需要实现Runnable接口。
不共享数据的情况：
/**
* Created by Administrator on 2017/2/20/020.
*/
public class MyThread extends Thread {
public MyThread(String name){
super();
this.setName(name);
}
private int count = 5;
@Override
public void run() {
super.run();
while (count > 0){
count--;
System.out.println("由"+this.currentThread().getName()+"计算，count="+count);
}
}
}
/**
* Created by LeeHom on 2017/3/20/020.
*/
public class Run {
public static void main(String[] args) {
MyThread a = new MyThread("A");
MyThread b = new MyThread("B");
MyThread c = new MyThread("C");
a.start();
b.start();
c.start();
}
}
结果
共享数据情况：
/**
* Created by Administrator on 2017/3/20.
*/
public class MyThread extends Thread {
private int count = 5;
@Override
public void run() {
super.run();
count--;
System.out.println("由"+this.currentThread().getName()+"计算，count="+count);
}
}
/**
* Created by Administrator on 2017/3/20.
*/
public class Run {
public static void main(String[] args) {
MyThread myThread = new MyThread();
Thread a = new Thread(myThread,"A");
Thread b = new Thread(myThread,"B");
Thread c = new Thread(myThread,"C");
Thread d = new Thread(myThread,"D");
Thread e = new Thread(myThread,"E");
a.start();
b.start();
c.start();
d.start();
e.start();
}
}
结果
通过结果发现线程A和B的count都是3，出现了非线程安全的问题，解决此问题只需要在run()前加一个synchronized关键字。synchronized可以对任意对象及方法上加锁。
/**
* Created by Administrator on 2017/3/20.
*/
public class MyThread extends Thread {
private int count = 5;
@Override
synchronized public void run() {
super.run();
count--;
System.out.println("由"+this.currentThread().getName()+"计算，count="+count);
}
}
加上 synchronized 后
currentThread() : 可以返回代码段正在被哪个线程调用的信息
isAlive() : 判断当前的线程是否处于活动状态
sleep()：作用是在指定的毫秒数内让【当前正在执行的线程】休眠，这个正在执行的线程指的是this.currentThread()返回的线程。
yield()：作用是放弃当前的CPU资源，将它让给其他的任务去占用CPU执行时间。但放弃的时间不确定，有可能刚刚放弃，马上又获得CPU时间片。
- sleep例：
public class MyThread1 extends Thread {
@Override
public void run() {
super.run();
try{
System.out.println("run threadName="+this.currentThread().getName()+"begin="+System.currentTimeMillis());
Thread.sleep(2000);
System.out.println("run threadName="+this.currentThread().getName()+"end="+System.currentTimeMillis());
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
public class Run {
public static void main(String[] args) {
MyThread1 myThread1 = new MyThread1();
System.out.println("begin="+System.currentTimeMillis());
myThread1.start();
System.out.println("end="+System.currentTimeMillis());
}
}
结果：run threadName=Thread-0end=1490021893169是过两秒出现的
结果
停止线程
-
停止一个线程意味着在线程处理完任务之前停掉正在做的操作，也就是放弃当前的操作。大多数停止一个线程的操作使用的是
Thread.interrupt()，这个方法不会终止一个正在运行的线程，还需要加一个判断才可以完成线程的停止 -
判断线程是否是停止状态
Thread.java提供了两种方法-
this.interrupted()：返回布尔类型，测试当前线程是否处于中断状态，执行后会将状态标志清除为false
-
public class Run {
public static void main(String[] args) {
Thread.currentThread().interrupt();
System.out.println("是否停止1？="+Thread.interrupted());
System.out.println("是否停止2？="+Thread.interrupted());
System.out.println("end!");
}
}
this.interrupted()
-
this.isInterrupted()：返回布尔，测试线程Thread 对象是否已经是中断状态，但不清除状态标志
public class Run {
public static void main(String[] args) {
Thread.currentThread().interrupt();
System.out.println("是否停止1？="+Thread.isInterrupted());
System.out.println("是否停止2？="+Thread.isInterrupted());
System.out.println("end!");
}
}
结果：（没有清除状态标志）
是否停止1？=true 是否停止2？=true
线程的优先级
在操作系统中，线程可以划分优先级，优先级较高的线程可以得到的CPU资源较多，也就是CPU优先执行优先级较高的线程对象中的任务。设置线程优先级使用setPriority()方法。
- 线程的优先级具有继承性，比如A线程启动B线程，则B线程的优先级与A是一样的
- 优先级具有规则性
高优先级的线程总是大部分先执行完，但不代表高优先级的线程全部执行完，当线程优先级差距很大时，谁先执行完和代码的调用顺序无关。
**结论：优先级较高的线程，并不一定每次都先执行完run()方法中的任务，他们的关系具有不确定性和随机性 **
守护线程
在java线程中有两种线程，一种是用户线程，一种是守护线程。只要当前JVM实例中存在任何一个非守护线程没有结束，守护线程就在工作，只有当最后一个非守护线程结束时，守护线程才和JVM一起结束工作。【典型的守护线程就是垃圾回收线程】
网友评论