public class Rabbit extends Thread {
@Override
public void run() {
for(int i=0;i<1000;i++) {
System.out.println("兔子跑---"+i+"步--");
}
}
}
public class DemoApplicationTests {
public static void main(String[] args) {
Rabbit rabbit = new Rabbit();
rabbit.start();
for(int i=0;i<1000;i++) {
System.out.println("main跑---"+i+"步--");
}
}
}
main跑—962步–
兔子跑—39步–
main跑—963步–
兔子跑—40步–
main跑—964步–
兔子跑—41步–
main跑—965步–
兔子跑—42步–
main跑—966步–
兔子跑—43步–
main跑—967步–
兔子跑—44步–
main跑—968步–
因为java是单继承多实现,所以用Thread就占用了继承位置,可以通过实现runnable接口来实现进程
public class DemoApplicationTests {
public static void main(String[] args) {
Rabbit rabbit = new Rabbit();
//静态代理
Thread proxy = new Thread(rabbit);
proxy.start();
for(int i=0;i<1000;i++) {
System.out.println("main跑---"+i+"步--");
}
}
public class Rabbit implements Runnable {
@Override
public void run() {
for(int i=0;i<1000;i++) {
System.out.println("兔子跑---"+i+"步--");
}
}
main跑—965步–
main跑—966步–
main跑—967步–
兔子跑—594步–
main跑—968步–
兔子跑—595步–
main跑—969步–
public class Web12306 implements Runnable {
private int ticket=1000;
@Override
public void run() {
while (true) {
if(ticket<0) {
System.out.println("票卖完了");
break;
}
System.out.println(Thread.currentThread().getName()+"抢到了"+ticket--+"号的票");
}
}
}
public class DemoApplicationTests {
public static void main(String[] args) {
Web12306 web = new Web12306();
Thread t1 = new Thread(web,"农民工");
Thread t2 = new Thread(web,"码农");
Thread t3 = new Thread(web,"土豪");
t1.start();
t2.start();
t3.start();
}
农民工抢到了10号的票
土豪抢到了11号的票
农民工抢到了8号的票
码农抢到了9号的票
农民工抢到了6号的票
土豪抢到了7号的票
农民工抢到了4号的票
码农抢到了5号的票
农民工抢到了2号的票
土豪抢到了3号的票
农民工抢到了0号的票
票卖完了
码农抢到了1号的票
票卖完了
票卖完了
callable可以实现有返回值,可以抛异常的线程。用起来比较繁琐
新生:new出来,通过start()来进入就绪状态
就绪状态:具备运行条件,如果cpu调用,就可以进入运行状态
运行状态:在CPU中运行
阻塞:永远不会进入CPU,除非解除阻塞
死亡:执行完毕或者destroy
public static void main (String[] args) {
Rabbit rabbit = new Rabbit();
rabbit.start();
for(int i=0;i<1000;i++) {
System.out.println("mian-------------->"+i);
if(300 == i){
try{
//等rabbit这个线程执行完毕再执行别人
rabbit.join();
//暂停线程,但是说不定下一秒还是调用它
//Thread.yield();在哪个线程里调用这个方法就暂停谁
}catch (Exception e){
}
}
}
}
public class Rabbit extends Thread {
@Override
public void run() {
for(int i=0;i<1000;i++) {
System.out.println("兔子跑---"+i+"步--");
}
}
}
mian————–>297
mian————–>298
mian————–>299
mian————–>300
兔子跑—0步–
兔子跑—1步–
兔子跑—2步–
兔子跑—3步–
兔子跑—4步–
兔子跑—5步–
兔子跑—6步–
兔子跑—7步–
兔子跑—8步–
兔子跑—9步–
兔子跑—10步–
兔子跑—11步–
兔子跑—12步–
兔子跑—13步–
sleep
Thread t;
t.setName()
t.getName()//获取线程名称
Thread.currentThread().getName()//获取当前线程名称
boolean t.isAlive();//返回是否存活
优先级
/**
* The minimum priority that a thread can have.
*/
public final static int MIN_PRIORITY = 1;
/**
* The default priority that is assigned to a thread.
* 默认是5
*/
public final static int NORM_PRIORITY = 5;
/**
* The maximum priority that a thread can have.
*/
public final static int MAX_PRIORITY = 10;
setPriority(int newPriority)
更改线程的优先级。
t1.set(MIN_PRIORITY)
t2.set(MAX_PRIORITY);
//t2执行的概率变高
前面卖票线程不安全
土豪抢到了8号的票
农民工抢到了8号的票
这是不加 public synchronized void test2()
synchronized(this) {
//同步代码块
}
单例设计模式会出现线程问题
syncronized Student getInstance();
class Student{
static Student getInstance(){
//没有对象,只能锁类的字节码
syncronized(Student.class){
}
}
死锁
过多的同步会造成死锁
生产者和消费者问题:解决死锁
void wait();//释放锁,等待
sleep()抱着锁睡觉
notify唤醒
notifyAll唤醒所有
生产双:88
我在吃:蛋糕双双:88
生产单:89
我在吃:蛋糕单单:89
生产双:90
生产单:91
我在吃:蛋糕单单:91
我在吃:蛋糕单单:91
public class cake {
String cake;
//生产蛋糕
public void product(String cake) {
this.cake=cake;
}
//消费蛋糕
public void consume() {
System.out.println("我在吃:"+cake);
}
}
public class Producter implements Runnable {
private cake c;
public Producter(cake c) {
this.c = c;
}
@Override
public void run() {
for (int i=1;i<200;i++) {
if(0 == i%2) {
c.product("蛋糕双双:"+i);
System.out.println("生产双:"+i);
}else {
c.product("蛋糕单单:"+i);
System.out.println("生产单:"+i);
}
try {
Thread.sleep(100);
}catch (Exception e) {
}
}
}
public class Consumer implements Runnable{
private cake c;
public Consumer(cake c) {
this.c = c;
}
@Override
public void run() {
for (int i=1;i<200;i++) {
c.consume();
try {
Thread.sleep(100);
}catch (Exception e) {
}
}
}
}
public static void main (String[] args) throws Exception{
cake c = new cake();
Producter producter = new Producter(c);
Consumer consumer = new Consumer(c);
new Thread(producter).start();
new Thread(consumer).start();
}
完全体
public class cake {
String cake;
//True:我做蛋糕,等着别吃,做完告诉你
//false:我吃,等着别做,吃完告诉你
boolean flag=true;
//生产蛋糕
public synchronized void product(String cake) {
//生产者等待,因为消费者在消费
if(!flag) {
try {
this.wait();
}catch (Exception e){
}
}
this.cake=cake;
System.out.println("生产");
//通知消费者苏醒
this.notify();
//让生产者沉睡
this.flag=false;
}
//消费蛋糕
public synchronized void consume() {
if(flag) {
try {
this.wait();
}catch (Exception e){
}
}
System.out.println("我在吃:"+cake);
this.notify();
this.flag=true;
}
}
public class Producter implements Runnable {
private cake c;
public Producter(cake c) {
this.c = c;
}
@Override
public void run() {
for (int i=1;i<200;i++) {
if(0 == i%2) {
c.product("蛋糕双双:"+i);
}else {
c.product("蛋糕单单:"+i);
}
}
}
}
public class Consumer implements Runnable{
private cake c;
public Consumer(cake c) {
this.c = c;
}
@Override
public void run() {
for (int i=1;i<200;i++) {
c.consume();
}
}
}
public static void main (String[] args) throws Exception{
cake c = new cake();
Producter producter = new Producter(c);
Consumer consumer = new Consumer(c);
new Thread(producter).start();
new Thread(consumer).start();
}
我在吃:蛋糕双双:196
生产
我在吃:蛋糕单单:197
生产
我在吃:蛋糕双双:198
生产
我在吃:蛋糕单单:199
public static void main (String[] args) throws Exception{
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("这是定时器,程序运行的当前时间一秒后执行,间隔2秒执行一次");
}
}
, new Date(System.currentTimeMillis() + 1000), 2000);
}