java基础——并发1
一.并发的定义
并发：对于这个概念一直就是没怎么搞懂，就是感觉特别的生疏，（自己从从字面上理解就是多个东西，一起出发），所以就上网上查了一些资料：
同时拥有两个或多个线程，如果程序在单核处理器上运行，多个线程将交替地换入或者换出内存，这些线程是同时“存在”的，每个线程都处于执行过程中的某个状态，如果运行在多核处理器上，此时，程序中的每个线程都将分配到一个处理器核上，因此可以同时运行。
高并发(High Concurrency)：
是互联网分布式系统架构设计中必须考虑的因素之一，它通常是指，通过设计保证系统能够同时并行处理很多请求。
两者区别：
并发：多个线程操作相同的资源，保证线程安全，合理使用资源。
高并发(High Concurrency)：服务能同时处理很多请求，提高程序性能
二.线程的定义
1.线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。
在网上查资料线程是这么定义的，其实说简单点，线程其实就是可以多个同时进行，也称之为多线程。下面是个生活中的例子
比如一天突然来一个电话，张三跟我说：“他的朋友李四的卡里面没有钱了，想让我借给他的朋友点
，我之后便去银行，到了银行，我先把钱转给张三，之后张三再把钱转到他的朋友李四的卡里。
其实，这个例子就是多线程的同时操作，第一个线程是 我把钱转到张三的卡里面 ；第二个线程是 张三在把钱转到李四的卡里。
在有一个例子：都听过龟兔赛跑的事情吧！这其实也是多线程的问题
兔子和乌龟同时从原点出发，比谁先到终点，这其实就是两个多线程共同进行，且互不影响。
在譬如说：咱们运行一个程序，程序没开始运行的时候是静态的，经过进程，再到线程，
它真正执行的也就是线程，其中main()称之为主线程。
在实际生活中多线程也是非常有用的，
比如，我们在浏览器上可以同时下载几张图片。
上面所说的都是线程的例子，它还是与我们生活密切相关的，用处也是非常大的。
线程就是独立的执行路径
在程序运行时，即使没有自己创建线程，后台也会有多少少线程，如主线程，gc线程
main()称之为主线程，为系统的入口，用于执行整个程序
在一个进程中，如果开辟了多少线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能认为的干预的。
对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
每个线程在自己的工作内存交互，内存控制不会造成吧数据不一致。
三.怎样实现多线程？
1.继承Thread类实现多线程的能力
package com.kuang.demo1;
//创建Thread类 重写run()方法 调用start()方法
//线程开始不一定立即执行，由CPU执行
public class TestThread1 extends Thread{
@Override
public void run() {
//run()方法线程
for(int i=0;i<20;i++) {
System.out.println("我爱写代码--" +i);
}
}
public static void main(String[] args) {
//main线程 主线程
//创建一个线程
TestThread1 testThread1 = new TestThread1();
//调用start()方法开启线程
testThread1.start();
for(int i=0;i<20;i++) {
System.out.println("我爱学习多线程" + i);
}
}
}
2.实现Runnable接口建立多线程
package com.kuan了解即可丢入runnable接口实现类，调用start方法
public class TestThread2 implements Runnable{
@Override
public void run() {
//run方法线程体
for(int i=0;i<20;i++) {
System.out.println("我在看代码--" + i);
}
}
public static void main(String [] args) {
//创建runnable实现接口类的线程
TestThread2 testThread2 = new TestThread2();
new Thread(testThread2).start();
for(int i=0;i<20;i++) {
System.out.println("我在学习多线程--" + i);
}
}
}
3.实现Callable接口(这个我就不举代码例子了，了解即可)
1.实现Callable接口，需要返回值类型
2.重写call方法，需要抛出异常
3.创建目标对象
4.创建执行服务:ExecutorService ser = Excutors.newFixedThreadPool(1);
5.提交执行:Future<Boolean> result1 = ser.submit(t1);
6.获取结果:boolean r1 = result.get();
7.关闭服务：ser.shutdownNow();
项目实例——龟兔赛跑
package com.kuang.demo1;
//模拟龟兔赛跑
public class Race implements Runnable {
//胜利者
private static String winner;
@Override
public void run() {
for(int i=0;i<=100;i++) {
//模拟兔子休息，设置让他十步卡以下
if(Thread.currentThread().getName().equals("兔子")&&( i+1)%10==0) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//判断比赛是否结束
boolean flag = gameOver(i);
//如果比赛结束，就停止程序
if(flag) {
break;
}
System.out.println(Thread.currentThread().getName() +"-->跑了" + i + "步");
}
}
//判断是否完成比赛
private boolean gameOver(int steps) {
//判断是否有胜利者
if(winner!=null) {
return true;
}{
if(steps>=100) {
winner = Thread.currentThread().getName();
System.out.println("winner is " + winner);
return true;
}
}
return false;
}
public static void main(String[] args) {
Race race = new Race();
new Thread(race,"兔子").start();
new Thread(race,"乌龟").start();
}
}
运行结果：
兔子-->跑了0步
兔子-->跑了1步
乌龟-->跑了0步
乌龟-->跑了1步
兔子-->跑了2步
乌龟-->跑了2步
乌龟-->跑了3步
乌龟-->跑了4步
兔子-->跑了3步
乌龟-->跑了5步
乌龟-->跑了6步
兔子-->跑了4步
兔子-->跑了5步
乌龟-->跑了7步
乌龟-->跑了8步
乌龟-->跑了9步
兔子-->跑了6步
兔子-->跑了7步
兔子-->跑了8步
乌龟-->跑了10步
乌龟-->跑了11步
乌龟-->跑了12步
乌龟-->跑了13步
乌龟-->跑了14步
乌龟-->跑了15步
乌龟-->跑了16步
乌龟-->跑了17步
乌龟-->跑了18步
乌龟-->跑了19步
乌龟-->跑了20步
乌龟-->跑了21步
乌龟-->跑了22步
乌龟-->跑了23步
乌龟-->跑了24步
乌龟-->跑了25步
乌龟-->跑了26步
乌龟-->跑了27步
乌龟-->跑了28步
乌龟-->跑了29步
乌龟-->跑了30步
乌龟-->跑了31步
乌龟-->跑了32步
乌龟-->跑了33步
乌龟-->跑了34步
乌龟-->跑了35步
乌龟-->跑了36步
乌龟-->跑了37步
乌龟-->跑了38步
乌龟-->跑了39步
乌龟-->跑了40步
乌龟-->跑了41步
乌龟-->跑了42步
乌龟-->跑了43步
乌龟-->跑了44步
乌龟-->跑了45步
乌龟-->跑了46步
乌龟-->跑了47步
乌龟-->跑了48步
乌龟-->跑了49步
乌龟-->跑了50步
乌龟-->跑了51步
乌龟-->跑了52步
乌龟-->跑了53步
乌龟-->跑了54步
乌龟-->跑了55步
乌龟-->跑了56步
乌龟-->跑了57步
乌龟-->跑了58步
乌龟-->跑了59步
乌龟-->跑了60步
乌龟-->跑了61步
乌龟-->跑了62步
乌龟-->跑了63步
乌龟-->跑了64步
乌龟-->跑了65步
乌龟-->跑了66步
乌龟-->跑了67步
乌龟-->跑了68步
乌龟-->跑了69步
乌龟-->跑了70步
乌龟-->跑了71步
乌龟-->跑了72步
乌龟-->跑了73步
乌龟-->跑了74步
乌龟-->跑了75步
乌龟-->跑了76步
乌龟-->跑了77步
乌龟-->跑了78步
乌龟-->跑了79步
乌龟-->跑了80步
乌龟-->跑了81步
乌龟-->跑了82步
乌龟-->跑了83步
乌龟-->跑了84步
乌龟-->跑了85步
乌龟-->跑了86步
乌龟-->跑了87步
乌龟-->跑了88步
乌龟-->跑了89步
乌龟-->跑了90步
乌龟-->跑了91步
乌龟-->跑了92步
乌龟-->跑了93步
乌龟-->跑了94步
乌龟-->跑了95步
乌龟-->跑了96步
乌龟-->跑了97步
乌龟-->跑了98步
乌龟-->跑了99步
winner is 乌龟
四.lambda表达式
Lambda 表达式（lambda expression）是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象（lambda abstraction），是一个匿名函数，即没有函数名的函数。
Java 8的一个大亮点是引入Lambda表达式，使用它设计的代码会更加简洁。当开发者在编写Lambda表达式时，也会随之被编译成一个函数式接口。
函数式接口：只包含一个抽象方法
package com.kuang.lambda;
/*
*推到lambda表达式
*函数式接口：只包含一个抽象方法
*/
public class TestLambda1{
//2.静态内部类
static class Like2 implements ILike{
@Override
public void Lambda() {
System.out.println("I like Lambda2");
}
}
public static void main(String[] args) {
//用接口创建对象
ILike like = new Like();
like.Lambda();
like = new Like2();
like.Lambda();
//3.局部内部类
class Like3 implements ILike{
@Override
public void Lambda() {
System.out.println("I like Lambda3");
}
}
like = new Like3();
like.Lambda();
//4.匿名内部类，需要new一个接口，没有类的名称，必须借助接口
like = new ILike() {
@Override
public void Lambda() {
System.out.println("I like Lambda4");
}
};
like.Lambda();
//5.用Lambda简化
like = ()->{
System.out.println("I like Lambda5");
};
like.Lambda();
}
}
//1.定义一个接口
interface ILike{
void Lambda();
}
//实现接口
class Like implements ILike{
@Override
public void Lambda() {
System.out.println("I like Lambda1");
}
}
运行结果：
I like Lambda1
I like Lambda2
I like Lambda3
I like Lambda4
I like Lambda5
在举一个就光是lambda用法的例子，lambda用法的核心语句就是
对象=（所要强调的）->{
};
package com.kuang.lambda;
public class TestLambda2{
public static void main(String[] args) {
ILove love =(int a )-> {
System.out.println("I Love You -->" + a);
};
love=(a)->{
System.out.println("I Love You -->" + a);
};
love.love(2);
}
}
interface ILove{
void love(int a);
}
运行结果：
I Love You -->2
五.线程的5种状态
New(新建)，Runnable(可运行)，堵塞和等待， 运行，Terminated(终止)
1.线程停止
不推荐使用JDK提供的stop(),destory()方法
推荐线程自己停止下来
建议使用一个标志位进行终止变量 当flag=false,则终止线程运行。
例如下列实例：
整体思路：首先设立一个标志flag为真，之后进行重写,当flag真的时候输出线程。
其次设立一个公开的方法停止线程，在这里我们不要其它的方法，用stop()就可以，令this.flag=false 主函数创建一个对象，
之后主函数new Thread().start();的形式启动它 进行设置循环多少次，输出一个main线程，令i等于几的时候线程停止 对象.stop();
下面那个例子我设定的是一共进行20次循环 main()线程第五次的时候，线程终止了。
这是代码的核心要点
public class TestStop implements Runnable{
//线程种定义线程体使用的标记
private boolean flag=true;
@Override
public void run(){
//线程体使用该标记
while(flag){
System.out.println("run......Thread");
}
}
//对外提供方法改变标识
public void stop(){
this.flag=false;
}
}
完整代码如下图所示：
package com.kuang.state;
import java.util.Iterator;
//测试stop
//j建议线程正常停止-->,利用次数，不建议死循环
//建议使用标志位-->设置一个标志为
//
public class TestStop implements Runnable {
//1.设置一个标志为
private boolean flag = true;
@Override
public void run() {
int i=0;
while(flag) {
System.out.println("run......Thread" + i ++);
}
}
//设置一个公开的方法停止线程，转换标志位
public void stop() {
this.flag=false;
}
public static void main(String[] args) {
TestStop teststop= new TestStop();
new Thread(teststop).start(); //启动
for(int i=0;i<20;i++) {
System.out.println("main线程" + i);
if(i==5) {
//调用stop方法切换标志位，让该线程停止
teststop.stop();
System.out.println("线程停止了");
}
}
}
}
运行结果：
main线程0
run......Thread0
main线程1
run......Thread1
run......Thread2
main线程2
run......Thread3
main线程3
main线程4
run......Thread4
main线程5
线程停止了
run......Thread5
main线程6
main线程7
main线程8
main线程9
main线程10
main线程11
main线程12
main线程13
main线程14
main线程15
main线程16
main线程17
main线程18
main线程19
2.线程礼让Yield
在API中有一个这样的方法 static void yield()
指的是：当前正在执行的线程向另一个线程交出运行权，注意，这是一个静态方法。
要点：
1.礼让(yield)线程，让当前正在执行的线程暂停，但不堵塞。
2.将线程从运行状态转为就绪状态
3.让CPU重新调度，礼让不一定成功！看CPU的心情。
代码实例：
package com.kuang.demo1;
//测试礼让线程
//礼让不一定成功，看cpu的心情
public class TestYiled {
public static void main(String[] args) {
MyYield myYield = new MyYield();
new Thread(myYield ,"a").start();
new Thread(myYield ,"b").start();
}
}
class MyYield implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "线程开始了");
Thread.yield();//礼让
System.out.println(Thread.currentThread().getName()+ "线程结束了");
}
}
运行结果：
第一次：
b线程开始了
a线程开始了
b线程结束了
a线程结束了
第二次：
a线程开始了
a线程结束了
b线程开始了
b线程结束了
看！它的运行结果是变化的，因为“礼让”有时候不一定会成功，他需要看CPU的心情。
3.线程休眠sleep
线程休眠总结：
1.sleep（时间)指定当前堵塞的毫秒数
2.sleep存在异常interruptedException
3.sleep时间达到后线程进入就绪状态
4.*每个对象都有一个一个锁，sleep不会释放锁
下面例子是Thread.sleep()的用法
package com.kuang.demo1;
//模拟网络延迟的作用：放大问题的发生性
public class TestSleep implements Runnable {
//票数
private int ticketNums=10;
@Override
public void run() {
while(true) {
if(ticketNums<=0) {
break;
}
//模拟延时
try {
Thread.sleep(100);
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "票");
}
}
public static void main(String[] args) {
TestSleep ticket = new TestSleep();
new Thread(ticket ,"小明").start();
new Thread(ticket ,"老师").start();
new Thread(ticket ,"黄牛党").start();
}
}
看下面的运行结果，结果显示黄牛党拿到了-1张票，通过模拟线程，好处是把问题给呈现出来了
小明-->拿到了第9票
黄牛党-->拿到了第9票
老师-->拿到了第10票
老师-->拿到了第8票
小明-->拿到了第8票
黄牛党-->拿到了第8票
黄牛党-->拿到了第7票
小明-->拿到了第6票
老师-->拿到了第6票
老师-->拿到了第5票
小明-->拿到了第4票
黄牛党-->拿到了第3票
老师-->拿到了第2票
小明-->拿到了第2票
黄牛党-->拿到了第2票
老师-->拿到了第0票
小明-->拿到了第1票
黄牛党-->拿到了第-1票
模拟倒计时 主要练习tenDown()的用法
package com.kuang.demo1;
public class TestSleep1 {
public static void main(String[] args) {
try {
tenDown();
}catch(InterruptedException e) {
e.printStackTrace();
}
}
//模拟倒计时
public static void tenDown() throws InterruptedException{
int num=10;
while(true) {
Thread.sleep(1000);
System.out.println(num--);
if(num<=0) {
break;
}
}
}
}
运行结果：
10
9
8
7
6
5
4
3
2
1
模拟日常时间倒计时
在上一个的基础上添加上Data用法，和时间格式符
package com.kuang.demo1;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestSleep1 {
public static void main(String[] args) {
//打印当前系统时间
Date startTime = new Date(System.currentTimeMillis()); //获得系统当前时间
while(true) {
try {
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime)); //输出时间格式化工厂
startTime = new Date(System.currentTimeMillis()); //更新当前时间
}catch(InterruptedException e) {
e.printStackTrace();
}
}
}
//模拟时间倒计时
public static void tenDown() throws InterruptedException{
int num=10;
while(true) {
Thread.sleep(1000);
System.out.println(num--);
if(num<=0) {
break;
}
}
}
}
代码结果
16:36:18
16:36:19
16:36:20
16:36:21
16:36:22
16:36:23
16:36:24
16:36:25
16:36:26
16:36:27
16:36:28
16:36:29
16:36:30
16:36:31
16:36:32
16:36:33
16:36:34
16:36:35
16:36:36
.......
.......
.......
它会一直这样输出.
4.新建线程
是通过new操作符创建一个新线程时，如new Thread(r),这个线程还没有运行，这就意味着它的状态是新建(new).
5.线程强制执行join
当线程等待另一个线程通过调度器出现一个条件，这个线程会进入等待状态.通过Object.wait(),Thread.join()方法,或者是等待java.util.concurrent库中的Lock或Condition时会出现这种情况。
总结：
1.Join合并线程，待此线程执行完成之后，在执行其他线程，其他线程堵塞
2.可以想象成插队
代码：
package com.kuang.demo1;
//测试join方法
//想象成排队
public class TestJoin implements Runnable {
@Override
public void run() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
for(int i=0;i<10;i++) {
System.out.println("线程VIP来了" + i);
}
}
public static void main(String[] args) throws InterruptedException {
//启动我们的线程
TestJoin testjoin = new TestJoin();
Thread thread = new Thread(testjoin);
thread.start();
//主线程
for(int i=0;i<50;i++){
if(i==25) {
thread.join();//插队
}
System.out.println("main" + i);
}
}
}
运行结果：
main0
main1
main2
main3
main4
main5
main6
main7
main8
main9
main10
main11
main12
main13
main14
main15
main16
main17
main18
main19
main20
main21
main22
main23
main24
线程VIP来了0
线程VIP来了1
线程VIP来了2
线程VIP来了3
线程VIP来了4
线程VIP来了5
线程VIP来了6
线程VIP来了7
线程VIP来了8
线程VIP来了9
main25
main26
main27
main28
main29
main30
main31
main32
main33
main34
main35
main36
main37
main38
main39
main40
main41
main42
main43
main44
main45
main46
main47
main48
main49
在i=25之前是CPU调度的，随机，当i>25之后就开始先执行VIP了。
六.判断线程所处的状态
package com.kuang.demo1;
//观察测试线程的状态
public class TestState {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(()->{
for(int i=0;i<5;i++) {
try {
Thread.sleep(1000);
}catch(InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("我爱写代码");
});
//观察状态
Thread.State state = thread.getState();
System.out.println(state); //NEW
thread.start(); //启动线程
state = thread.getState();
System.out.println(state);
while(state!=Thread.State.TERMINATED){
Thread.sleep(100);
state = thread.getState(); //更新线程状态
System.out.println(state); //输出状态
}
}
}
运行结果：从中可以看出一个线程所处的状态一次经过new Runnable 堵塞 运行 终止 这五个状态
NEW
RUNNABLE
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
我爱写代码
TERMINATED
今天先写到这里，之后的同步，锁，线程池等我会陆续加载出来的，希望能帮助到您们。
请 大 家 多 多 关 注 ！
java基础——并发1的更多相关文章
- [Java 基础] 并发队列ConcurrentLinkedQueue和阻塞队列LinkedBlockingQueue用法
reference : http://www.cnblogs.com/linjiqin/archive/2013/05/30/3108188.html 在Java多线程应用中,队列的使用率很高,多数生 ...
- Java基础-并发篇
3.1. JAVA 并发知识库 3.2. JAVA 线程实现/创建方式 3.2.1. 继承 Thread 类 Thread 类本质上是实现了 Runnable 接口的一个实例,代表一个线程的实例. ...
- JAVA基础（9）——容器（3）——并发容器
转载:http://blog.csdn.net/weitry/article/details/52964509 JAVA基础系列规划: JAVA基础(1)——基本概念 JAVA基础(2)——数据类型 ...
- 图学java基础篇之并发
概述 并发处理本身就是编程开发重点之一,同时内容也很繁杂,从底层指令处理到上层应用开发都要涉及,也是最容易出问题的地方.这块知识也是评价一个开发人员水平的重要指标,本人自认为现在也只是学其皮毛,因此本 ...
- Java基础之二十 并发
20.1 并发得多面性 并发编程令人困惑的一个主要原因:使用并发时需要解决的问题有多个,而实现并发的方法也有多种,并且在这两者之间没有明显的映射关系. 20.1.1 更快的执行 速度问题初听起来很简单 ...
- Java基础】并发 - 多线程
Java基础]并发 - 多线程 分类: Java2014-05-03 23:56 275人阅读 评论(0) 收藏 举报 Java 目录(?)[+] 介绍 Java多线程 多线程任务执行 大多数 ...
- Java高并发编程基础三大利器之CountDownLatch
引言 上一篇文章我们介绍了AQS的信号量Semaphore<Java高并发编程基础三大利器之Semaphore>,接下来应该轮到CountDownLatch了. 什么是CountDownL ...
- Java基础技术多线程与并发面试【笔记】
Java基础技术多线程与并发 什么是线程死锁? 死锁是指两个或两个以上的进程(线程)在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去,我们就可以称 ...
- 【Java基础】线程和并发机制
前言 在Java中,线程是一个很关键的名词,也是很高频使用的一种资源.那么它的概念是什么呢,是如何定义的,用法又有哪些呢?为何说Android里只有一个主线程呢,什么是工作线程呢.线程又存在并发,并发 ...
随机推荐
- 4.Linux的目录结构
Linux的目录结构 (1)"/"目录 Linux文件系统的入口,也是出于最高一级的目录 (2)"/bin" 基础系统所需要的那些命令位于此目录.也是最小系统所 ...
- [Objective-C] 001_Hello Objective-C
"Hello Word"从来都是经典中的经典!今天我们就来个"Hello Objective-C"吧. 启动Xcode(6.3.1),从File菜单中选择New ...
- [SD喜爱语言PK大赛]001.PHP vs Node.js
引言:近日,两大编程飓风之战已经愈演愈烈.在程序员社区,一些争端因PHP与Node.js而起. 观点:其实就本人及团队而言,Language just a language!不存在高低之分,而侧重的原 ...
- 用pandas处理数据遇到的坑
1.使用pandas.read_csv(filePath)方法来读取csv文件时,可能会出现这种错误:ParserError:Error tokenizing data.C error:Expecte ...
- CE未知数值修改
一样,用植物大战僵尸测试.来搜索修改向日葵生产阳光的CD值. 由于开始并不知道向日葵cd的初始值,所以用CE搜索未知的初始值 返回游戏,每次向日葵晃一下搜索一下减少的值. 锁定修改为0发现成功. 然后 ...
- Linux （七）权限控制
个人博客网:https://wushaopei.github.io/ (你想要这里多有) 1. 概述 Linux需要对登录用户读写执行文件.进入目录.查看增删目录内容等操作进行控制,不能任由用户 ...
- 一招解决GitHub致命的下载速度（GitHub下载速度慢怎么办）
通过码云来导入github,通过码云下载 第一步: 找一个你需要下载的GitHub项目 第二步: 复制链接 第三步: 打开码云,然后选择从GitHub导入 第四步: 复制刚才的连接,起个名字,点击导入 ...
- Java实现 LeetCode 539 最小时间差（单位转换）
539. 最小时间差 给定一个 24 小时制(小时:分钟)的时间列表,找出列表中任意两个时间的最小时间差并已分钟数表示. 示例 1: 输入: ["23:59","00:0 ...
- Java实现 蓝桥杯VIP 算法提高 11-2删除重复元素
算法提高 11-2删除重复元素 时间限制:10.0s 内存限制:256.0MB 问题描述 为库设计新函数DelPack,删除输入字符串中所有的重复元素.不连续的重复元素也要删除. 要求写成函数,函数内 ...
- Java实现 LeetCode 100 相同的树
100. 相同的树 给定两个二叉树,编写一个函数来检验它们是否相同. 如果两个树在结构上相同,并且节点具有相同的值,则认为它们是相同的. 示例 1: 输入: 1 1 / \ / \ 2 3 2 3 [ ...