线程：

• 定义：线程是程序内的一个单一的顺序控制流程，也被称为“轻型进程(lightweight process)” 或“执行上下文(execution context )”
• 线程用于分隔任务
• 线程类似于传统的顺序程序，都有一个执行的起点，经过一系列指令后到达终点。线程在执行过程中的任何时刻只能有一个执行点
• main()是一个特殊的线程

实现方法：

1.继承Thread

2.实现runnable接口

启动方式：

1.start() 交叉执行线程，一个等待即执行下一个，各个线程的xc1.start（）;

xc2.start();

xc3.start();

执行并不是顺序的，谁先获取cpu执行谁

2.run()  顺序执行线程，一个执行完才能执行下一个

线程共享资源：

设置为static静态

线程状态：

创建

就绪

执行

阻塞

死亡

线程通信：

线程常用方法：

Thread.currentThread().getName();获取正在执行的线程的名字

//主动放弃cpu执行权的三种方法

Thread.yield();thread的静态方法，当前执行线程放弃cpu执行权进入就绪态；

Thread.sleep(t); thread的静态方法，睡眠一段时间，进入阻塞态，时间到自动进入就绪态；

wait([t]);Object方法等待【一定时间】进入阻塞态，等待唤醒

notify（）唤醒持有指定锁阻塞状态的线程任意一个，进入就绪

notifyAll()唤醒持有指定锁阻塞状态的所有进程，进入就绪

stop()终止线程

thread.setPriority(1--10);//线程优先级，1—10越来越大，只是提高获取cpu的概率，并不是优先级高的绝对先获取cpu

继承Thread过程

1.创建一个类继承Thread

2.重写Thread中的run方法 （创建线程是为了执行任务     任务代码必须有存储位置，run方法就是任务代码的存储位置。）thread里的run()可以调用其他方法

3.创建子类对象，其实就是在创建线程

4.启动线程start（）或者run()

这种方式的特点（缺陷）：线程任务和线程是绑定在一起的。

实例：

class Ticket extends Thread{

    private static int num = 50; //定义成static，四个线程共享50张票。

    public void run() {

        while(num>0)

        System.out.println(Thread.currentThread().getName()+"...sale..."+num--);

    }

}

class Maipiao{

    public static void main(String[] args) {

        Ticket win1 = new Ticket();

        Ticket win2 = new Ticket();

        Ticket win3 = new Ticket();

        Ticket win4 = new Ticket();

        win1.start();

        win2.start();

        win3.start();

        win4.start();

    }

}

实现runnable接口：过程

1. 创建类并实现Runnable接口
2. 重写Runnable接口中的run方法
3. 创建实现了Runnable接口的子类的对象
4. 创建Thread类的对象，也就是在创建线程
5. 把实现了Runnable接口的子类对象作为参数传递给Thread类的构造方法

实例：

package thread;

/**

 * 应用模块名称<p>

 * 代码描述<p>

 * Copyright: Copyright (C) 2019 XXX, Inc. All rights reserved. <p>

 * Company: 河南863<p>

 *

 * @author 闫聪

 * @since 2019/7/19 10:26

 */

public class Demo2 {

    public static void main(String[] args) {

        MyThreadTwo myThreadTwo = new MyThreadTwo();

        Thread thread=new Thread(myThreadTwo,"窗口1");

        Thread thread2=new Thread(myThreadTwo,"窗口2");

        Thread thread3=new Thread(myThreadTwo,"窗口3");

        Thread thread4=new Thread(myThreadTwo,"窗口4");

        thread.start();

        thread2.start();

        thread3.start();

        thread4.start();

        //myThreadTwo.start();

    }

}

class MyThreadTwo implements Runnable{

    //方式二：成员变量属于共享资源，多个线程共享一个对象

    private int num =100;

    @Override

    public void run() {

System.out .println ("ss"+num);

     synchronized (this){

            while(num>0){

                num=num-1;

                if(num==0){

                    this.notifyAll();

                    break;

                }

                System.out.println(Thread.currentThread().getName()+"...sale..."+num);

                if(num<100&&num%2==0){

                    this.notify();

                    try {

                        this.wait();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

            }

       }

    }

}

Java学习笔记——线程

原文：https://www.cnblogs.com/ldlihmk1314/p/11335236.html