进程 ： 正在执行的程序称作为一个进程。 进程负责了内存空间的划分。
问题： windows号称是多任务的操作系统,那么windows是同时运行多个应用程序吗？
- 从宏观的角度： windows确实是在同时运行多个应用程序。
- 从微观角度： cpu是做了一个快速切换执行的动作，由于速度态度，所以我感觉不到在切换 而已。
线程： 线程在一个进程 中负责了代码的执行，就是进程中一个执行路径，
多线程： 在一个进程中有多个线程同时在执行不同的任务。
疑问 ：线程负责了代码 的执行，我们之前没有学过线程，为什么代码可以执行呢？
运行任何一个java程序，jvm在运行的时候都会创建一个main线程执行main方法中所有代码。
一个java应用程序至少有几个线程？
至少有两个线程， 一个是主线程负责main方法代码的执行，一个是垃圾回收器线程,负责了回收垃圾。
多线程的好处：
- 解决了一个进程能同时执行多个任务的问题。
- 提高了资源的利用率。
多线程 的弊端：
- 增加cpu的负担。
- 降低了一个进程中线程的执行概率。
- 引发了线程安全 问题。
- 出现了死锁现象。
如何创建多线程：
方式一：
- 自定义一个类继承Thread类。
- 重写Thread类的run方法 , 把自定义线程的任务代码写在run方法中
- 创建Thread的子类对象，并且调用start方法开启线程
疑问： 重写run方法的目的是什么？
每个线程都有自己的任务代码，jvm创建的主线程的任务代码就是main方法中的所有代码, 自定义线程的任务代码就写在run方法中，自定义线程负责了run方法中代码。
。
注意： 一个线程一旦开启，那么线程就会执行run方法中的代码，run方法千万不能直接调用，直接调用run方法就相当调用了一个普通的方法而已并没有开启新的线程。
public class Demo1 extends Thread {
@Override //把自定义线程的任务代码写在run方法中。
public void run() {
for(int i = 0 ; i < 100 ; i++){
System.out.println("自定义线程："+i);
}
}
public static void main(String[] args) {
//创建了自定义的线程对象。
Demo1 d = new Demo1();
//调用start方法启动线程
d.start();
for(int i = 0 ; i < 100 ; i++){
System.out.println("main线程："+i);
}
}
}
需求： 模拟QQ视频与聊天同时在执行。
class TalkThread extends Thread{
@Override
public void run() {
while(true){
System.out.println("hi，你好！开视频呗...");
}
}
}
class VideoThread extends Thread{
@Override
public void run() {
while(true){
System.out.println("视频视频....");
}
}
}
public class Demo2 {
public static void main(String[] args) {
TalkThread talkThread = new TalkThread();
talkThread.start();
VideoThread videoThread = new VideoThread();
videoThread.start();
}
}
方式二：
- 自定义一个类实现Runnable接口。
- 实现Runnable接口 的run方法，把自定义线程的任务定义在run方法上。
- 创建Runnable实现类对象。
- 创建Thread类 的对象，并且把Runnable实现类的对象作为实参传递。
- 调用Thread对象 的start方法开启一个线程。
问题1： 请问Runnable实现类的对象是线程对象吗？
Runnable实现类的对象并 不是一个线程对象，只不过是实现了Runnable接口 的对象而已。
只有是Thread或者是Thread的子类才是线程 对象。
问题2：为什么要把Runnable实现类的对象作为实参传递给Thread对象呢？作用是什么？
作用就是把Runnable实现类的对象的run方法作为了线程的任务代码去执行了。
推荐使用： 第二种。 实现Runable接口的。
原因： 因为java单继承 ,多实现的。
public class Demo3 implements Runnable{
@Override
public void run() {
/*System.out.println("this："+ this);
System.out.println("当前线程："+ Thread.currentThread());
这个在实现Thread类中是一样的,但是在这里是不一样的,this是Runnable实现类
但是当前线程是主方法中创建的Thread对象启用的线程
*/
for(int i = 0 ; i < 100 ; i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
public static void main(String[] args) {
//创建Runnable实现类的对象
Demo3 d = new Demo3();
//创建Thread类的对象， 把Runnable实现类对象作为实参传递。
Thread thread = new Thread(d,"狗娃"); //Thread类使用Target变量记录了d对象，
//调用thread对象的start方法开启线程。
thread.start();
for(int i = 0 ; i < 100 ; i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
/*
Thread类 的run方法
* @Override
public void run() {
if (target != null) {
target.run(); //就相当于Runnable实现类的对象的run方法作为了Thread对象的任务代码了。
}
}
*/
}
线程常用的方法：
Thread(String name) 初始化线程的名字
setName(String name) 设置线程对象名
getName() 返回线程的名字
sleep() 线程睡眠指定的毫秒数。 静态的方法， 那个线程执行了sleep方法代码那么就是那个线程睡眠。
currentThread() 返回当前的线程对象，该方法是一个静态的方法， 注意： 那个线程执行了currentThread()代码就返回那个线程 的对象。
getPriority() 返回当前线程对象的优先级 默认线程的优先级是5
setPriority(int newPriority) 设置线程的优先级 虽然设置了线程的优先级，但是具体的实现取决于底层的操作系统的实现（最大的优先级是10 ，最小的1 ， 默认是5）。
public class Test07 extends Thread {
public Test07(String name){
super(name); //调用了Thread类的一个参数的构造方法.(设置线程名称)
}
@Override
public void run() {
/*System.out.println("this:"+ this);
System.out.println("当前线程对象：" + Thread.currentThread()); */
for (int i = 0; i < 100 ; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
/*try {
Thread.sleep(100); //为什么在这里不能抛出异常，只能捕获？？ Thread类的run方法没有抛出异常类型，所以子类不能抛出异常类型。
} catch (InterruptedException e) {
e.printStackTrace();
} */
}
}
public static void main(String[] args) throws InterruptedException {
//创建了一个线程对象
Test07 d = new Test07("狗娃");
//d.sleep(1000); 虽然是d调用的sleep方法,但是该方法是在主线程中执行的,所以是主线程睡眠
d.setPriority(10); //设置线程 的优先级。 优先级的数字越大，优先级越高 ， 优先级的范围是1~10
d.start();
for (int i = 0; i < 100 ; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
/*
System.out.println("自定义线程的优先级："+d.getPriority()); //线程的优先级默认是5
System.out.println("主线程的优先级："+Thread.currentThread().getPriority());
d.start();
d.setName("铁蛋"); //setName设置线程的名字
d.start(); //开启线程
Thread mainThread = Thread.currentThread();
System.out.println("主线程的名字："+ mainThread.getName());
*/
}
}
需求： 模拟3个窗口同时在售50张 票 。
问题1 ：为什么50张票被卖出了150次？
原因： 因为num是非静态的，非静态的成员变量数据是在每个对象中都会维护一份数据的,三个线程对象就会有三份。
解决方案：把num票数共享出来给三个线程对象使用。使用static修饰。
问题2： 出现了线程安全问题 ?
线程 安全问题的解决方案：sun提供了线程同步机制让我们解决这类问题的。
java线程同步机制的方式：
方式一：同步代码块
同步代码块的格式：
synchronized(锁对象){
需要被同步的代码...
}
同步代码块要注意事项：
1. 任意的一个对象都可以做为锁对象。
2. 在同步代码块中调用了sleep方法并不是释放锁对象的。
3. 只有真正存在线程安全问题的时候才使用同步代码块，否则会降低效率的。
4. 多线程操作的锁 对象必须 是唯一共享 的。否则无效。
需求： 一个银行账户5000块，两夫妻一个拿着 存折，一个拿着卡，开始取钱比赛，每次只能取一千块，要求不准出现线程安全问题。
方式二：同步函数 ： 同步函数就是使用synchronized修饰一个函数。
同步函数要注意的事项 ：
1. 如果是一个非静态的同步函数的锁 对象是this对象，如果是静态的同步函数的锁 对象是当前函数所属的类的字节码文件（class对象）。
2. 同步函数的锁对象是固定的，不能由你来指定 的。
推荐使用： 同步代码块。
原因：
1. 同步代码块的锁对象可以由我们随意指定，方便控制。同步函数的锁对象是固定 的，不能由我们来指定。
2. 同步代码块可以很方便控制需要被同步代码的范围，同步函数必须是整个函数 的所有代码都被同步了。
*/
class SaleTicket extends Thread{
static int num = 50;//票数 非静态的成员变量,非静态的成员变量数据是在每个对象中都会维护一份数据的。
static Object o = new Object();
public SaleTicket(String name) {
super(name);
}
@Override
public void run() {
while(true){
//同步代码块
synchronized ("锁") { //静态字符常量也可以,因为常量区只会存在一份
if(num>0){
System.out.println(Thread.currentThread().getName()+"售出了第"+num+"号票");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
num--;
}else{
System.out.println("售罄了..");
break;
}
}
}
}
}
public class Demo4 {
public static void main(String[] args) {
//创建三个线程对象，模拟三个窗口
SaleTicket thread1 = new SaleTicket("窗口1");
SaleTicket thread2 = new SaleTicket("窗口2");
SaleTicket thread3 = new SaleTicket("窗口3");
//开启线程售票
thread1.start();
thread2.start();
thread3.start();
}
}
/*
java中同步机制解决了线程安全问题，但是也同时引发死锁现象。
死锁现象：
死锁现象出现 的根本原因：
1. 存在两个或者两个以上的线程。
2. 存在两个或者两个以上的共享资源。
死锁现象的解决方案： 没有方案。只能尽量避免发生而已。
*/
class DeadLock extends Thread{
public DeadLock(String name){
super(name);
}
public void run() {
if("张三".equals(Thread.currentThread().getName())){
synchronized ("遥控器") {
System.out.println("张三拿到了遥控器，准备 去拿电池!!");
synchronized ("电池") {
System.out.println("张三拿到了遥控器与电池了，开着空调爽歪歪的吹着...");
}
}
}else if("狗娃".equals(Thread.currentThread().getName())){
synchronized ("电池") {
System.out.println("狗娃拿到了电池，准备去拿遥控器!!");
synchronized ("遥控器") {
System.out.println("狗娃拿到了遥控器与电池了，开着空调爽歪歪的吹着...");
}
}
}
}
}
public class Demo2 {
public static void main(String[] args) {
DeadLock thread1 = new DeadLock("张三");
DeadLock thread2 = new DeadLock("狗娃");
//开启线程
thread1.start();
thread2.start();
}
}
