课程概要：
进程与线程
- 线程中单独顺序的控制流
线程本身依靠程序进行运行
- 进程：执行中的程序
一个进程可以包含一个或者多个线程
一个进程至少要包含一个线程 - 单线程
程序中只存在一个线程，实际主方法就是一个主线程 - 多线程：
多线程是在一个程序中运行多个任务
多线程的目的是更好地使用CPU资源
线程的实现
第一种方式：通过继承thread方式实现进程（需要调用thread.start()方法才能实现线程的并发
public class MyThread extends Thread{
private String name;//用来标示线程
public MyThread(String name) {
this.name=name;
}
@Override
public void run() {//必须重写的方法
for(int i=1;i<=1000;i++)
{
System.out.print(name+i);
if(i%10==0){
System.out.println();
}
}
super.run();
}
}
MyThread t1=new MyThread("A");
MyThread t2=new MyThread("b");
t1.start();
t2.start();
}
第二种方式：
通过实现runnable 方法，然后获得runnable对象，将runnable对象传递给Thread 的构造方法，创建thread对象。然后调用thread.start()
即可实现。
示例代码：
public class MyRunnable implements Runnable{
private String name;
public MyRunnable(String name) {
this.name=name;
}
@Override
public void run() {
for(int i=1;i<=1000;i++)
{
System.out.print(name+i);
if(i%10==0){
System.out.println();
}
}
}
}
MyRunnable r1=new MyRunnable("a");
MyRunnable r2=new MyRunnable("b");
Thread t1=new Thread(r1);
Thread t2=new Thread(r2);
t1.start();
t2.start();
}
输出结果：（并发机制谁抢到CPU资源就谁执行）
线程的状态
线程的常用方法
- 取得线程名称
getName()
- 取得当前线程对象
currentThread() - 判断线程是否启动
isAlive() - 线程的强行运行
join() - 线程的休眠
sleep()
将使任务终止执行给定的时间。 - 线程的让步
yield()
这个方法按时这个线程的工作已经完成得差不多了，可以让别的线程使用CPU了，同事也是在建议其他具有相同优先级的线程可以运行。
示例代码（1 2 3）：
class MyRunnable2 implements Runnable{
private String name;
public MyRunnable2(String name) {
this.name=name;
}
@Override
public void run() {
for(int i=0;i<5;i++)
{
System.out.println("线程正在运行~~~");
}
}
}
public class ThreadDemo02 {
public static void main(String[] args) {
MyRunnable2 r1=new MyRunnable2("jun");
Thread t1=new Thread(r1);
t1.start();
System.out.println("线程是否启动:"+t1.isAlive());
System.out.println("当前线程对象是："+Thread.currentThread());
System.out.println("取得线程名称:"+t1.getName());
}
}
输出结果：
4.join
在其他线程里使用join，能强行让方法对象线程执行。
例如在主线程里边强行执行自定义线程
示例代码：
public class ThreadDemo02 {
public static void main(String[] args) {
MyRunnable2 r1=new MyRunnable2("jun");
Thread t1=new Thread(r1);
t1.start();
for(int i=0;i<=50;i++){
if(i>10){
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("主线程"+i);
}
}
}
运行结果：
sleep：
示例代码：
在run方法里边调用
public void run() {
for(int i=0;i<5;i++)
{
try {
Thread.sleep(1000);
System.out.println("线程正在运行~~~");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
结果：控制台每隔一秒输出
线程正在运行~~~
线程的优先级
常用方法:
getPriority()读取现有线程的优先级
setPriority()设置或者修改线程的优先级
- 注意：
1.java调度器倾向于让优先级别高的线程先执行（不保证），这并不意味着优先级别比较低的线程就不执行（优先级别并不会导致死锁）。优先级别低的线程仅仅是执行频率比较低。
2.jdk有10个优先级，但与多数操作系统都不能映射得很好（比如Windows有七个优先级）。推荐可移植的方法是调整优先级的时候只是用MAX_PRIORITY 、 NORM_PRIORITY 、 MIN_PRIORITY
示例代码：
public class ThreadDemo02 {
public static void main(String[] args) {
MyRunnable1 r1=new MyRunnable1("min");
MyRunnable1 r2=new MyRunnable1("normal");
MyRunnable1 r3=new MyRunnable1("max");
Thread t1=new Thread(r1);
Thread t2=new Thread(r2);
Thread t3=new Thread(r3);
t1.setPriority(Thread.MIN_PRIORITY);
t2.setPriority(Thread.NORM_PRIORITY);
t3.setPriority(Thread.MAX_PRIORITY);
t1.start();
t2.start();
t3.start();
}
}
输出结果：
一开始按顺序执行，后来优先级别高的线程先执行。
同步与死锁
多线程线程执行一个runnable对象，由于线程无法共享，会产生无法预计的错误。
一般在资源需要共享的时候需要同步。
示例代码：
创建三个线程完成一个run方法，当ticket数为0的时候停止，预计结果为5、4、3、2、1
class MyRunnable1 implements Runnable{
private String name;
private int tickets=5;
public MyRunnable1(String name) {
this.name=name;
}
@Override
public void run() {
for(int i=0;i<5;i++)
{
if(tickets>0){
try {
Thread.sleep(500);
System.out.println(Thread.currentThread()+"车票"+tickets--);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
public class ThreadDemo02 {
public static void main(String[] args) {
MyRunnable1 r1=new MyRunnable1("me");
Thread t1=new Thread(r1);
Thread t2=new Thread(r1);
Thread t3=new Thread(r1);
t1.start();
System.out.println(t1.getName());
t2.start();
System.out.println(t2.getName());
t3.start();
System.out.println(t3.getName());
}
}
输出结果：
为了解决这个问题实现线程同步,可以使用synchronized关键字
synchronized关键字
它的修饰对象有几种：
- 修饰一个类，其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象。
- 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
- 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
- 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
修饰一个类
其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象，如下代码：
public void method() {
synchronized(ClassName.class) {
// todo
}
}
}
修饰一个方法
Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，例如：
public synchronized void method(){ // todo}
另外，有几点需要注意：
- 在定义接口方法时不能使用synchronized关键字。
- 构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。
- synchronized 关键字不能被继承。如果子类覆盖了父类的 被 synchronized 关键字修饰的方法，那么子类的该方法只要没有 synchronized 关键字，那么就默认没有同步，也就是说，不能继承父类的 synchronized。
修饰静态方法
我们知道静态方法是属于类的而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的所有对象。如下：
public synchronized static void method() { // todo}
修饰代码块
//todo
}```
* 当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
* 当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
* 尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
以上规则对其它对象锁同样适用.
##线程的生命周期
