个人理解：加同步锁等的时候，就可以让线程”按顺序排队“，一个一个地抢CPU，一个抢完对应的每次有的CPU了，另一个才抢对应的每次有的CPU，解决”并发“问题等。

自己写的礼让(个人的理解:礼让就是选择放弃独占CPU,

选择和其他线程分享抢到的CPU)例子题目：打印循环累加1的num，用上同步锁使之不乱序(个人的理解：同步锁的作用等就是让打印的线程启动等后的结果，不是乱序，而是有序，有逻辑和规律的)

：

/**

*

*/

package thread;

import java.util.Random;

public class jinKuang {

public static void main(String[] args) throws Exception{

personClass personClass=new personClass();

new Thread(personClass, "三连").start();

new Thread(personClass, "关注").start();

new Thread(personClass, "诗书画唱").start();

}

}

class personClass implements Runnable{

static int num=0;

@Override

public void run() {

while(true){

synchronized (this) {

try {

Thread.sleep(10);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

num++;

System.out.println(Thread.currentThread()

.getName()+"抢到当前CPU,现在num的值为"+num);

//个人理解:礼让就是选择放弃独占CPU,

//选择和其他线程分享抢到的CPU

if(num%5==0){

Thread.yield();

//yield英[jiːld]

//美[jiːld]

//v.出产(作物); 产生(收益、效益等);

//提供; 屈服; 让步; 放弃; 缴出;

//n.产量; 产出; 利润;

System.out.println(Thread.currentThread()

.getName()+"进行了礼让");

}

if(num==100){

try {

Thread.sleep(10);

System.out.println("休息一下");

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

if(num==200){

break;

}

}

}

}

}

设计一个线程，模拟买票场景，现有100张票，

使用3个线程进行购买车票

方法一：

package thread;

import java.util.Random;

public class cheZhan {

public static void main(String[] args) throws Exception{

chePiaoClass chePiaoClass=new chePiaoClass() ;

//下面是省了重命名的部分，直接new实例化：

new Thread(chePiaoClass, "长沙站").start();

new Thread(chePiaoClass, "北京站").start();

new Thread(chePiaoClass,"山东站").start();

}

}

class chePiaoClass implements Runnable{

static int piaoShu=100;//总票数

public void run() {

//票数大于0就可以卖票：

while(piaoShu>0){

//加synchronized的话，打印出来的才

//会有从大到小等的顺序等。

//不然的话，打印出的内容等就会很乱，

//这是安全性出了问题

synchronized (this) {

//synchronized关键字是用来控制线程同步的，

//就是在多线程的环境下，

//控制synchronized代码段不被多个线程同时执行。

//

//synchronized是Java中的关键字，是一种同步锁。

//synchronized:

//英[ˈsɪŋkrənaɪzd]

//美[ˈsɪŋkrənaɪzd]

//v.(使) 同步，在时间上一致，同速进行

try {

Thread.sleep(100);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

if(piaoShu>0){

System.out.println(Thread.currentThread()

.getName()+"卖出了第"+piaoShu+"张票");

}piaoShu--;}

}

}

}

方法二：

package thread;

import java.util.Random;

public class piao implements Runnable{

static int num;

static int count;

piao(){

num = 100;

count = 0;

}

@Override

public void run() {

while(num > 0){

synchronized (this) {

try{

Thread.sleep(new Random().nextInt(20));

}catch(Exception e){

e.printStackTrace();

}

if(num > 0){

System.out.println(Thread.currentThread().getName()

+"_____买的票数号码"+num);

num --;

count ++;}

}

}

}

public static void main(String[] args){

piao ticket = new piao();

for(int line = 1 ; line <= 3 ; line ++){

new Thread(ticket,"线程名：线程"+line).start();

}

}

}

创建一个兔子类，一个乌龟类，进行赛跑，目标为10米，

兔子每跑1米休息0.05秒，规定生成随机数，兔子生成的随机数范围为0-5，生成的随机数为3时才开始跑一米,乌龟生成的随机数范围0-20，生成的随机数为13的时候才开始跑一米,乌龟每跑一米休息0.01秒 ,使用线程模拟这个特定龟兔赛跑的过程：

/**

*

*/

package thread;

import java.util.Random;

public class tuZi {

//垃圾回收线程：

//执行垃圾回收的线程，称为垃圾回收线程。

public static void main(String[] args) throws Exception{

//2.创建一个兔子类，一个乌龟类，进行赛跑，目标为10米，

//兔子每跑1米休息0.05秒，兔子的随机范围为0-5，随机到3开始跑,

//  乌龟随机范围0-20，随机到13的时候开始跑,

//乌龟没跑一米休息0.01秒 ,使用线程模拟

wuGuiClass wuGuiClass=new wuGuiClass();

new Thread(wuGuiClass,"乌龟").start();

tuZiClass tuZiClass=new tuZiClass();

new Thread(tuZiClass,"兔子").start();

}

}

class wuGuiClass implements Runnable{

static int weiZhi=0;//：开始的位置为0米的位置

Random RandomNum=new Random();

public void run() {

while(true){//如果没有到终点一直跑

//乌龟每跑一米休息0.01秒

//设置他们跑的速度就用随机数去设置

int shuzi=RandomNum.nextInt(25);

System.out.println("乌龟生成的随机数为"+shuzi);

//乌龟随机到13之后才开始跑

if(shuzi==13){

weiZhi++;//每次生成的随机数为13时跑一米

System.out.println("乌龟共跑了"+weiZhi+"米");

}

try {

Thread.sleep(10);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

//乌龟或者兔子不管谁到终点，都用break停止所有线程

if(wuGuiClass.weiZhi>=10||tuZiClass.weiZhi>=10){

//怎么判断谁赢了

if(wuGuiClass.weiZhi>=10){

System.out.println("乌龟胜利");

}

if(tuZiClass.weiZhi>=10){

System.out.println("兔子胜利");

}

break;

}

}

}

}

class tuZiClass implements Runnable{

static int weiZhi=0;//开始的位置为0米的位置

Random RandomNum=new Random();

public void run() {

while(true){//如果没有到终点一直跑，

//兔子每跑一米休息0.05秒，用上sleep

int tuZiNum=RandomNum.nextInt(5);

System.out.println("兔子生成的随机数为了"+tuZiNum);

if(tuZiNum==3){

weiZhi++;//每次生成的随机数为3时跑一米

System.out.println("兔子共跑了"+weiZhi+"米");

}

try {

Thread.sleep(50);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

if(wuGuiClass.weiZhi>=10||tuZiClass.weiZhi>=10){

//用两个if判断谁赢了

if(wuGuiClass.weiZhi>=10){

System.out.println("乌龟胜利");

}

if(tuZiClass.weiZhi>=10){

System.out.println("兔子胜利");

}

break;

}

}

}

}

简述线程的生命周期

生命周期由4种状态组成：

1.就绪状态：实例化好了这个线程，但是并没有启动这个线程

2.可运行状态:启动了这个线程，但是这个线程并没有抢到cpu的使用权

3.运行状态:这个线程抢到了cpu的使用权

4.死亡状态:这个线程的代码全部执行完毕之后，就释放掉这个线程

//创建一个兔子类，一个乌龟类，进行赛跑，

//目标为100米，

//(1)兔子每 0.1 秒 5 米的速度，每跑20米休息0.1秒;

//(2)乌龟每 0.1 秒跑 2 米的速度，不休息,乌龟一直跑,使用线程模拟；

JS中回调函数(callback)理解：

字面上理解下来就是，回调就是一个函数的调用过程。那么就从理解这个调用过程开始吧。函数a有一个参数，这个参数是个函数b，当函数a执行完以后执行函数b。那么这个过程就叫回调。

其实中文也很好理解：回调，回调，就是回头调用的意思。函数a的事先干完，回头再调用函数b。

举个现实的例子：约会结束后你送你女朋友回家，离别时，你肯定会说：“到家了给我发条信息，我很担心你。”对不，然后你女朋友回家以后还真给你发了条信息。小伙子，你有戏了。

其实这就是一个回调的过程。你留了个函数b(要求女朋友给你发条信息)给你女朋友，然后你女朋友回家，回家的动作是函数a。她必须先回到家以后，函数a的内容执行完了，再执行函数b，然后你就收到一条信息了。

这里必须清楚一点：函数b是你以参数形式传给函数a的，那么函数b就叫回调函数。

也许有人有疑问了:一定要以参数形式传过去吗，我不可以直接在函数a里面调用函数b吗？确实可以。求解中。

解惑:如果你直接在函数a里调用的话，那么这个回调函数就被限制死了。但是使用函数做参数就有下面的好处：当你a(b)的时候函数b就成了回调函数，而你还可以a(c)这个时候，函数c就成了回调函数。如果你写成了function a(){...;b();}就失去了变量的灵活性。

含个人的超级详细的解析：

//创建一个兔子类，一个乌龟类，进行赛跑，

//目标为100米，

//(1)兔子每 0.1 秒 5 米的速度，每跑20米休息0.1秒;

//(2)乌龟每 0.1 秒跑 2 米的速度，不休息,乌龟一直跑,使用线程模拟；

package thread;

import java.util.Random;

import thread.Animal.Calltoback;

public class guiTuGame {

public static void main(String[] args) throws Exception{

// 实例化乌龟和兔子：

//tortoise英[ˈtɔːtəs]

//美[ˈtɔːrtəs]

//n.陆龟; 龟;

//————————————

//rabbit英[ˈræbɪt]

//美[ˈræbɪt]

//n.兔; 野兔; 兔肉;

//v.猎兔; 捕兔;

wuGuiDeClass wuGuiDeClass = new wuGuiDeClass();

rabbitClass rabbitClass = new rabbitClass();

// 回调方法的使用，谁先调用calltoback方法，另一个就不跑了

//        回调就是一个函数的调用过程。"call to back"："叫其回来"

//        那么就从理解这个调用过程开始吧。

//        函数a有一个参数，这个参数是个函数b，

//        当函数a执行完以后执行函数b。

//        那么这个过程就叫回调。

//        LetLoserStop:让败者停止线程的开启

//      当wuGuiDeClass wuGuiDeClass = new wuGuiDeClass();

//      部分的线程先结束(乌龟赢)时,

//        就会wuGuiDeClass传值

//        到回执函数,就会执行下面的一句的回执函数等,

//        calltoback != null,

//        就会执行乌龟类中的 calltoback.win();

//        让兔子类的也再次执行一次回执函数,让兔子停止

LetLoserStop letLoserStopWuGui =

new LetLoserStop(wuGuiDeClass);

// 让兔子的回调方法里面存在乌龟对象的值，可以把乌龟停止stop:

rabbitClass.calltoback =

letLoserStopWuGui;

LetLoserStop letLoserStopRabbit =

new LetLoserStop(rabbitClass);

// 让乌龟的回调方法里面存在兔子对象的值，可以把兔子停止stop:

wuGuiDeClass.calltoback = letLoserStopRabbit;

// 开始跑:

wuGuiDeClass.start();

rabbitClass.start();

}

}

//LetOneStop:让一个停止

//当有一个到达终点的时候,需要让没到终点的乌龟或兔子的线程停止

//,不然的话就会有这里"乌龟获得了胜利"和

//"兔子获得了胜利"都打印出来,所以要用回调函数

//Calltoback,当兔子和乌龟的线程执行时,有一方到达时候,就把

//这一方的参数传到回调函数,让回调函数中声明的stop方法起效果

class LetLoserStop implements Calltoback {

// 动物对象

Animal loserClass;

// 获取动物对象，可以传入兔子或乌龟的实例

public LetLoserStop(Animal loserClass) {

this.loserClass = loserClass;

}

// 让动物的线程停止:

public void win() {

// 线程停止用stop方法:

loserClass.stop();

}

}

class wuGuiDeClass extends Animal {

public wuGuiDeClass() {

setName("乌龟");// Thread的方法，给线程赋值名字

}

// 重写running方法，编写乌龟的奔跑操作

@Override

public void runing() {

// x:乌龟的位移:

int x = 2;

length -= x;

System.out.println("乌龟跑了" +

x + "米，距离终点还有" + length + "米");

if (length <= 0) {

length = 0;

System.out.println("乌龟获得了胜利");

// 让兔子不要在跑了

if (calltoback != null) {

calltoback.win();

}

}

try {

sleep(100);

//每0.1秒跑2米,用sleep实现速度的效果

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

class rabbitClass extends Animal {

public rabbitClass() {

setName("兔子");

}

@Override

public void runing() {

//X:兔子位移:

int x = 5;

length -= x;

System.out.println("兔子跑了" + x

+ "米，距离终点还有" + length + "米");

if (length <= 0) {

length = 0;

System.out.println("兔子获得了胜利");

// 给回调对象赋值，让乌龟不要再跑了

if (calltoback != null) {

calltoback.win();

}

}

try {

if ((2000 - length) % 20 == 0) {

// 每20米休息一次,休息时间是0.1秒

sleep(100);

} else {                //每0.1秒跑5米

sleep(100);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

//这里用动物类继承了线程类就

//可以有线程类等的特性等,在主函数传兔子类或乌龟类时,就不会报错等

abstract class Animal extends Thread {

public int length = 100;// 比赛长度

public abstract void runing();

@Override

public void run() {

super.run();

while (length > 0) {

runing();

}

}

// 在需要回调数据的地方(两个子类需要)，声明一个接口

public static interface Calltoback {

public void win();

}

// 2.创建接口对象

public Calltoback calltoback;

}

创建一个人物类，创建人物张三和李四共同去挖矿，用一个数字5代表金矿，声明随机数，当挖到金矿的时候，当前线程打印“呵呵，挖到金矿了”并且礼让线程，一共挖30次金矿，统计每个人挖到金矿的次数。

/**

*

*/

package thread;

import java.util.Random;

public class jinKuangClass {

public static void main(String[] args) throws Exception{

personClassJinKuang personClass=

new personClassJinKuang();

new Thread(personClass, "张三").start();

new Thread(personClass, "李四").start();

}

}

class personClassJinKuang implements Runnable{

static int num=0;

Random RandomNum=new Random();

@Override

public void run() {

while(true){

int tuZiNum=RandomNum.nextInt(10);

System.out.println("生成的随机数为"+tuZiNum);

synchronized (this) {

try {

Thread.sleep(10);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

if(tuZiNum==5){

num++;

System.out.println(Thread.currentThread()

.getName()+"抢到当前CPU,现在挖到的金矿次数为"+num+"次");

//个人理解:礼让就是选择放弃独占CPU,

//选择和其他线程分享抢到的CPU

if(num%5==0){

Thread.yield();

//yield英[jiːld]

//美[jiːld]

//v.出产(作物); 产生(收益、效益等);

//提供; 屈服; 让步; 放弃; 缴出;

//n.产量; 产出; 利润;

System.out.println(Thread.currentThread()

.getName()+"进行了礼让");

}}

if(num==100){

try {

Thread.sleep(100);

System.out.println("休息一下");

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

if(num>=200){

break;

}

}

}

}

}

个人对守护线程的理解：