一、自定义线程
进程 ： 正在执行的程序称作为一个进程。 进程负责了内存空间的划分。
线程： 线程在一个进程 中负责了代码的执行，就是进程中一个执行路径，
多线程： 在一个进程中有多个线程同时在执行不同的任务。
疑问 ：线程负责了代码 的执行，我们之前没有学过线程，为什么代码可以执行呢？
运行任何一个java程序，jvm在运行的时候都会创建一个main线程执行main方法中所有代码。
一个java应用程序至少有几个线程？
至少有两个线程， 一个是主线程负责main方法代码的执行，一个是垃圾回收器线程,负责了回收垃圾。
多线程的好处：
1. 解决了一个进程能同时执行多个任务的问题。
2. 提高了资源的利用率。
多线程 的弊端：
1. 增加cpu的负担。
2. 降低了一个进程中线程的执行概率。
3. 引发了线程安全 问题。
4. 出现了死锁现象。
创建线程的方式：
方式一：
1. 自定义一个类继承Thread类。
2. 重写Thread类的run方法 , 把自定义线程的任务代码写在run方法中
3. 创建Thread的子类对象，并且调用start方法开启线程。
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);
}
}
}
疑问： 重写run方法的目的是什么？
每个线程都有自己的任务代码，jvm创建的主线程的任务代码就是main方法中的所有代码, 自定义线程的任务代码就写在run方法中，自定义线程负责了run方法中代码。
注意： 一个线程一旦开启，那么线程就会执行run方法中的代码，run方法千万不能直接调用，直接调用run方法就相当调用了一个普通的方法而已并没有开启新的线程。
方式二：
1. 自定义一个类实现Runnable接口。
2. 实现Runnable接口 的run方法，把自定义线程的任务定义在run方法上。
3. 创建Runnable实现类对象。
4. 创建Thread类 的对象，并且把Runnable实现类的对象作为实参传递。
5. 调用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());*/
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对象的任务代码了。
}
}
*/
}
//需求：三个窗口卖50张票
class SaleTicket implements Runnable{
int num = 50; // 票数
@Override
public void run() {
while(true){
synchronized ("锁") {
if(num>0){
System.out.println(Thread.currentThread().getName()+"售出了第"+ num+"号票");
num--;
}else{
System.out.println("售罄了..");
break;
}
}
}
}
}
public class Demo4 {
public static void main(String[] args) {
//创建了一个Runnable实现类的对象
SaleTicket saleTicket = new SaleTicket();
//创建三个线程对象模拟三个窗口
Thread thread1 = new Thread(saleTicket,"窗口1");
Thread thread2 = new Thread(saleTicket,"窗口2");
Thread thread3 = new Thread(saleTicket,"窗口3");
//开启线程售票
thread1.start();
thread2.start();
thread3.start();
}
}
二、线程的生命周期
三、线程常用的方法
Thread(String name) 初始化线程的名字
setName(String name) 设置线程对象名
getName() 返回线程的名字
sleep() 线程睡眠指定的毫秒数。 静态的方法， 那个线程执行了sleep方法代码那么就是那个线程睡眠。
currentThread() 返回当前的线程对象，该方法是一个静态的方法， 注意： 那个线程执行了currentThread()代码就返回那个线程 的对象。
getPriority() 返回当前线程对象的优先级 默认线程的优先级是5
setPriority(int newPriority) 设置线程的优先级 虽然设置了线程的优先级，但是具体的实现取决于底层的操作系统的实现（最大的优先级是10 ，最小的1 ， 默认是5）。
public class Demo3 extends Thread {
public Demo3(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 {
//创建了一个线程对象
Demo3 d = new Demo3("狗娃");
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提供了线程同步机制让我们解决这类问题的。
出现线程安全问题的根本原因：
1. 存在两个或者两个以上 的线程对象,而且线程之间共享着一个资源。
2. 有多个语句操作了共享资源。
java线程同步机制的方式：
方式一：同步代码块
同步代码块的格式：
synchronized(锁对象){
需要被同步的代码...
}
同步代码块要注意事项：
1. 任意的一个对象都可以做为锁对象。
2. 在同步代码块中调用了sleep方法并不是释放锁对象的。
3. 只有真正存在线程安全问题的时候才使用同步代码块，否则会降低效率的。
4. 多线程操作的锁 对象必须 是唯一共享 的。否则无效。
需求： 一个银行账户5000块，两夫妻一个拿着 存折，一个拿着卡，开始取钱比赛，每次只能取一千块，要求不准出现线程安全问题。
public class demo extends Thread{
static int sum = 5000;
Object o = new Object();
public demo(String name){
super(name);
}
@Override
public void run() {
synchronized(o){
while(true){
if(sum>0){
System.out.println(this.currentThread().getName()+"取了1000块,还剩"+(sum-1000)+"元");
sum-=1000;
}else{
System.out.println("取光了。。");
break;
}
}
}
}
public static void main(String[] args) {
demo husband = new demo("丈夫");
demo wife = new demo("老婆");
husband.start();
wife.start();
}
}
方式二：同步函数
同步函数就是使用synchronized修饰一个函数。
//需求： 一个银行账户5000块，两夫妻一个拿着 存折，一个拿着卡，开始取钱比赛，每次只能取一千块，要求不准出现线程安全问题。
*/
class BankThread extends Thread{
static int count = 5000;
public BankThread(String name){
super(name);
}
@Override //
public synchronized void run() {
while(true){
synchronized ("锁") {
if(count>0){
System.out.println(Thread.currentThread().getName()+"取走了1000块,还剩余"+(count-1000)+"元");
count= count - 1000;
}else{
System.out.println("取光了...");
break;
}
}
}
}
//静态的函数---->函数所属 的类的字节码文件对象--->BankThread.class 唯一的。
public static synchronized void getMoney(){
}
}
public class Demo1 {
public static void main(String[] args) {
//创建两个线程对象
BankThread thread1 = new BankThread("老公");
BankThread thread2 = new BankThread("老婆");
//调用start方法开启线程取钱
thread1.start();
thread2.start();
}
}
同步函数要注意的事项 ：
1. 如果是一个非静态的同步函数的锁 对象是this对象，如果是静态的同步函数的锁 对象是当前函数所属的类的字节码文件（class对象）。
2. 同步函数的锁对象是固定的，不能由你来指定 的。
推荐使用： 同步代码块。
原因：
1. 同步代码块的锁对象可以由我们随意指定，方便控制。同步函数的锁对象是固定 的，不能由我们来指定。
2. 同步代码块可以很方便控制需要被同步代码的范围，同步函数必须是整个函数 的所有代码都被同步了。
五、死锁
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();
}
}
六、实现同步的几种方法：
synchronized、lock、wait()和notify()
synchronized与lock的区别：
1、synchronized是在JVM层面实现的，因此系统可以监控锁的释放与否，而ReentrantLock使用代码实现的，系统无法自动释放锁，需要在代码中finally子句中显式释放锁lock.unlock();
2、在并发量比较小的情况下，使用synchronized是个不错的选择，但是在并发量比较高的情况下，其性能下降很严重，此时ReentrantLock是个不错的方案。