佳哥 文涛 ❤
单线程
/**
* 并行：两个或多个事件在 同一时间发成 同时发生 两个CPU 执行两个任务
* 并发:两个或多个事件 在同一时间段执行 一个cpu交替执行
*
* 内存 所有的应用程序都会到内存中
* 线程 一个进程包含多个线程 列如：电脑管家里面的功能就是加速 清理 病毒查杀
* （cpu中央处理器 对数据进行计算 amd inter） 线程是进程中的一个执行单元
* 进程 进入大内存中的程序就是进程 idea 微信
*
* java 抢占式调度 高度切换 谁的优先级高 谁先执行
* 主线程 执行主方法的线程
*/
public class Demo {
//主线程 程序从main方法先执行
public static void main(String[] args) {//Jvm执行main方法进入栈内存 main方法通向cpu的路径
Person person =new Person("周一");
person.run();//单线程的异常
Person person1 =new Person("周二");
person1.run();
}
}
多线程
多线程直接互不影响
获取线程名称System.out.println(Demo.currentThread().getName()); 线程名称setName();==new MyThread(“线程名称").start
thread 常用方法sleep当前毫秒值内睡眠
实现接口方式创建多线程
public class Test {
public static void main(String[] args) {
/*
Runnable runnable = new Runnable();
Thread thread = new Thread(runnable);
thread.start();
for (int i = 0; i <20 ; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}*/
//匿名内部类 多线程 父类是Thread 调用run
/*new Thread(){
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() +"-->"+i);
}
}
}.start();*/
//匿名内部类实现接口的方式
java.lang.Runnable runnable =new java.lang.Runnable() {
@Override
public void run() {
for (int i =0; i <10 ; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
};
new Thread(runnable).start();
}
}
线程安全问题 电影售票的问题（共享数据会产生安全问题 按个窗口同时卖一些票） 多线程处理 三种方式处理现成安全的问题
public class Synchronuzedimplements java.lang.Runnable {
private int ticket=50;
// 使用锁 防止线程安全 创建锁对象lock unlock
Lockl=new ReentrantLock();
@Override
public void run() {
while (true){
pickTicket();
}
}
//使用同步方法
//还有静态的同步方法 直接在synchronized前面加Static
/* public synchronized void pickTicket(){
l.lock();
if (ticket>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"售票"+ticket);
ticket--;
}
//释放锁 所可以放在finally里面l.unlock();
}*/
//unlock 放在finally里面
public synchronized void pickTicket(){
l.lock();
if (ticket>0){
try {
Thread.sleep(10);
System.out.println(Thread.currentThread().getName()+"售票"+ticket);
ticket--;
}catch (InterruptedException e) {
e.printStackTrace();
}finally {
//释放锁 所可以放在finally里面
l.unlock();//正常的三个线程同时抢占cPU
}
}
}
}
main public class SynchronuzedMain {
public static void main(String[] args) {
Synchronuzed synchronuzed =new Synchronuzed();
Thread thread1 =new Thread(synchronuzed);
Thread thread2 =new Thread(synchronuzed);
Thread thread3 =new Thread(synchronuzed);
thread1.start();
thread2.start();
thread3.start();//(同步方法时)只可以一个线程执行
}
}
线程的状态 阻塞状态（）（ 主动放弃cpu休眠状态 无线等待状态 ）新建 运行 死亡
TimeWating 计时等待 notity 如果有多个线程等待 随机唤醒一个线程
notityAll唤醒所有等待的线程
/**
* 等待唤醒案例
* 消费者 需要什么样的包子 要告诉生产者 生产者做 所以消费者需要等待wating5秒中（sleep(5000)）
* 生产者 做包子 做完包子要唤醒notity消费者 告诉他可以吃包子了
*
* 通用包子 作为类Baozi
* 我们需要用到同步代码 保证和等待唤醒的是一个线程 同步技术
*
* */
public class Wating {
public static void main(String[] args) {
//创建锁对象 保证唯一
Object object =new Object();
//创建一个消费者
new Thread(){
@Override
public void run() {
//消费者告诉生产者 要什么样的包子
// Baozi baozi = new Baozi("紫色","剥皮");
//一直等着买包子
while (true){
synchronized (object){
System.out.println("告知生产者要的包子种类 数量");
//开始等待包子做好
try {
object.wait();
}catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("唤醒之后 可以吃包子了");
}
}
}
}.start();
//匿名对象 线程 创建一个生产者
new Thread(){
@Override
public void run() {
while (true){
try {
Thread.sleep(5000);
}catch (InterruptedException e) {
e.printStackTrace();
}
//同步技术
synchronized (object){
System.out.println("用了5秒做完了包子 告诉消费者可以吃包子了");
//唤醒他
object.notify();
}
}
//生产者 花了5秒做包子
}
}.start();
}
}
等待与唤醒机制 线程间的通信 （生产包子 吃包子）多个线程之间的协作机制 有效的利用资源 (生产一个包子 吃一个包子)
线程池 频繁的创建线程降低效率 可以用线程池来达到效果
线程池 的底层原理 一个容器-> 集合 hashMap Arraylist hashset LinkedList(常用)--> 容器有很多线程
程序第一次启动 创建多个线程保存到一个集合中 使用线程时 从集合中取出来 remove方法 返回的是被移除的元素 线程只能被一个任务使用
removeFirst移除第一个线程 使用完毕 需要把线程归还给线程池 list.add添加 队列的思想 线程排队
java5 线程池
