线程 同步
多线程
多线程的好处：多个线程之间互不影响(在不同的栈空间)
My Thread mt = new MyThread();
my.strat()；
//开启多线程
并发与并行
并发：指两个或多个事件在同一个时间段内发生(交替执行)
并行：指两个或多个事件在同一时刻发生（同时发生）
Thread类
构造方法：
public Thread() :分配一个新的线程对象
public Thread(String name) :分配一个指定名字的新的线程对象
public Thread(Runnable target) :分配一个带有指定目标新的线程对象
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字
常用方法：
public String getName() :获取当前线程名称。
public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run() :此线程要执行的任务在此处定义代码。
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。
获取线程的名称：
1.使用Thread类中的方法getName()；
String getName() 返回该线程的名称
2.可以先获取到当前正在执行的线程，使用线程中的方法getName( )获取线程的名臣
static Thread currentThread( ) 返回对当前正在执行的线程对象的引用
设置线程的名称：
1.使用Thread类中的方法setName(名字)
void setName(String name) 改变线程名称，使之与参数name相同
2.创建一个带参数的构造方法，参数传递线程的名臣，调用父类的带参构造方法，把线程名臣传递给父类，让父类(Thread)给子线程起一个名称
Thread(String name) 分配新的Thread对象
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）
毫秒数结束之后，线程继续执行
创建多线程程序的第一种方式创建Thread类的子类
要实现多线程程序，就必须继承Thread类
实现步骤：
1.传教一个Thread类的子类
2.在Thread类的子类中重写Thread类中的run方法，设置线程任务
3.创建Thread类的子类对象
4.调用Thread类中的方法start方法，开启新的线程，执行run方法
void start( ) 是该线程开始执行：Java虚拟机调用该线程的run方法
结果是两个线程并发的允许：当前线程(main)线程和另一个线程(创建的新线程，执行其run方法)
多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动
java程序属于抢占式调度
创建并启动多线程的步骤如下：
1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把
run()方法称为线程执行体。
2. 创建Thread子类的实例，即创建了线程对象
3. 调用线程对象的start()方法来启动该线程
代码：
public class Demo01 {
public static void main(String[] args) {
//创建自定义线程对象
MyThread mt = new MyThread("新的线程！");
//开启新线程
mt.start();
//在主方法中执行for循环
for (int i = 0; i < 10; i++) {
System.out.println("main线程！"+i);
}
}
}
创建多线程程序的第二种方式实现Runnable接口
Runable 接口应该由哪些打算通过某一线程执行其实例的类来实现。类必须定义一个陈伟run的无参数方法
构造方法：
public Thread(Runnable target) :分配一个带有指定目标新的线程对象
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字
步骤如下：
1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象
3. 调用线程对象的start()方法来启动线程
代码：
public class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+" "+i);
}
}
}
public class Demo {
public static void main(String[] args) {
//创建自定义类对象 线程任务对象
MyRunnable mr = new MyRunnable();
//创建线程对象
Thread t = new Thread(mr, "小强");
t.start();
for (int i = 0; i < 20; i++) {
System.out.println("旺财 " + i);
}
}
}
Thread和Runnable的区别
实现Runnable接口创建多线程程序的好处：
1.避免了单继承的局限性
一个类只能继承一个类，类继承了Thread类就不能继承其他的类
实现了Runnable接口，还可以继承其他的类，实现其他的接口
2.增强了程序的扩展性，降低了程序的耦合性(解耦)
实现了Runnable接口的方式，把设置线程任务和开启新县城进行了分离(解耦)
实现类中，重写了run方法:用来设置线程任务
创建Thread类对象，调用start方法:用来开启新线程
匿名内部类方式实现线程的创建
匿名：没有名字
内部类：写在其它内部的类
匿名内部类作用：简化代码
把子类继承父类，重写父类的方法，创建子类对象合一步完成
把实现实现类接口，重写接口中的方法，创建实现类对象合成一步完成
匿名内部类的最终产物：子类/实现类对象，而这个类没有名字
格式：
new 父类/接口( ){
重复父类/接口中的方法
};
线程与进程
一个程序运行后至少有一个进程，一个进程中可以包含多个线程
线程属于进程，是进程中的一个执行单位，负责程序的执行
线程调度：
分时调度
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间
抢占式调度
优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度
主线程：执行(main)方法的线程
单线程程序：java中只有一个线程
执行从main方法开始，从上到下依次执行
JVM执行main方法，main方法会进入到栈内存
JVM会找操作系统开辟一条main方法通向cpu的执行路径
cpu就可以通过这个路径来执行main方法，而这个路径有一个名字叫做main(主)线程
线程安全
线程同步
三种同步操作：
同步代码块
格式：
synchronized(同步锁){
需要同步操作的代码
}
注意：
1.通过代码块中的锁对象，可以使用任意的对象
2.但是必须保证多个线程使用的锁对象是同一个
3.锁对象的作用：
把同步代码块所著，只让一个线程在同步代码块中执行
代码：
public class Ticket implements Runnable{
private int ticket = 100;
Object lock = new Object();
/*
* 执行卖票操作
*/
@Override
public void run() {
//每个窗口卖票的操作
//窗口 永远开启
while(true){
synchronized (lock) {
if(ticket>0){//有票 可以卖
//出票操作
//使用sleep模拟一下出票时间
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// TODO Auto‐generated catch block
e.printStackTrace();
}
//获取当前线程对象的名字
String name = Thread.currentThread().getName();
System.out.println(name+"正在卖:"+ticket‐‐);
}
}总结：同步中的线程，没有执行完毕不会释放锁，同步外的线程没有锁进不去同步
同步方法
格式：
public synchronized void method(){
可能会产生线程安全问题的代码
}
使用步骤：
1.把访问了共享数据的代码块抽取出来，放到一个方法中
2.在方法上添加synchronized修饰符
代码：
public class Ticket implements Runnable{
private int ticket = 100;
/*
* 执行卖票操作
*/
@Override
public void run() {
//每个窗口卖票的操作
//窗口 永远开启
while(true){
sellTicket();
}
}
/*
* 锁对象 是 谁调用这个方法 就是谁
* 隐含 锁对象 就是 this
*
*/
public synchronized void sellTicket(){
if(ticket>0){//有票 可以卖
//出票操作
//使用sleep模拟一下出票时间
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto‐generated catch block
e.printStackTrace();
}
//获取当前线程对象的名字
String name = Thread.currentThread().getName();
System.out.println(name+"正在卖:"+ticket‐‐);
}
}
}同步锁是谁
对于非static方法,同步锁就是this
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)
静态同步方法
锁对象是谁：不能是this，this是创建对象之后产生的，静态方法优先于对象
静态方法的锁对象是本类的class属性-->class文件对象(反射)
锁机制
Lock锁
Lock接口中的方法：
public void lock() :加同步锁
public void unlock() :释放同步锁
Lock.ReecntrantLock implements Lock接口
步骤：
1.在成员位置创建一个ReentrantLock对象
2.在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
代码：
public class Ticket implements Runnable{
private int ticket = 100;
Lock lock = new ReentrantLock();
/*
* 执行卖票操作
*/
@Override
public void run() {
//每个窗口卖票的操作
//窗口 永远开启
while(true){
lock.lock();
if(ticket>0){//有票 可以卖
//出票操作
//使用sleep模拟一下出票时间
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// TODO Auto‐generated catch block
e.printStackTrace();
}
//获取当前线程对象的名字
String name = Thread.currentThread().getName();
System.out.println(name+"正在卖:"+ticket‐‐);
}
lock.unlock();
}
}
}