什么是多线程?
首先要了解进程,一个进程可以启用多个线程。
进程:
1.可以看做一个公司,线程就是公司的员工。
2.进程A和进程B的内存资源独立不共享
3.进程是线程的执行单元
线程:
1.线程A与线程B之间堆内存和方法区共享,栈是独立的,一个线程一个栈。
2.那假设启用10个线程,每个线程都对应一个栈,栈与栈之间互不干扰
这就是多线程并发,多线程并发提高效率
就是,单核中里面的线程要抢占时间片,两个线程来回切换,来回抢占,导致人有一种‘两个线程在同时进行的‘错觉’’。
。实际上,单核在一个时间点上只能执行一个线程。
5..run与.start的区别(也是并发并行的区别!!!!)
很有趣
s
弹幕讲的好啊,记录一下
6.线程生命周期
分为哪几种?
新建状态
就绪状态
运行状态
阻塞状态
死亡状态
掌握方法:
Thread.currentThread();//获取当前线程对象 t.getName;//获取线程名字(默认为Thread-0....++) t.setName;//更改线程对象名; t.start();//分支一个线程创建一个栈出来,该栈栈帧是run方法。 Thread.sleep( long ,int );//使当前线程睡眠1000毫秒*int t.interrupt();//唤醒线程:制造异常,使线程被trycatch捕捉抛出,中断睡眠。 t.stop();//(已过时)强行结束线程,缺点:可能会导致线程内未保存数据丢失。 在实现接口的类里创建一个布尔型变量来控制run方法if(布尔),如果想停止线程,可以在main里将布尔类型改成false,这样当main中执行到该语句时,run也就停止了, 需要注意的是,要将该类new出来,不能直接写到线程里。
package IOtext; public class ThreadText01 implements Runnable { public boolean run=true; public void run() { for (int i=0;i<100;i++) { if(run)//若run==false则该线程退出 { System.out.println(Thread.currentThread().getName()+"->"+i); try { Thread.sleep(1000); } catch (InterruptedException e) { throw new RuntimeException(e); } } else return; } } public static void main(String[] args) { ThreadText01 r=new ThreadText01(); Thread t=new Thread(r); t.start(); t.setName("001"); for (int i=0;i<5;i++) { try { Thread.sleep(1000*1); } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println(Thread.currentThread()+"->"+i); } r.run=false;//停止 } }
7.线程调度(了解内容)
8.线程安全(重点)
package Thread.ThreadSafe; public class BankAcd extends Thread{ private String id1; private int uesrmoney; public BankAcd(String id1, int uesrmoney) { this.id1 = id1; this.uesrmoney = uesrmoney; } public BankAcd(){} public String getId1() { return id1; } public void setId(String id) { this.id1 = id; } public int getUesrmoney() { return uesrmoney; } public void setUesrmoney(int uesrmoney) { this.uesrmoney = uesrmoney; } public void quqian(int money) { synchronized (this){ try { this.sleep(1000); } catch (InterruptedException e) { throw new RuntimeException(e); } int quqian= this.uesrmoney - money; this.setUesrmoney(quqian); } } }
synchronized (this)//这个是当有共享对象时,线程需要等;
synchronized (“dada”)//这个创建了一个字符串,因为字符串对象存储在字符串常量池里,所以所有的对象都可以使用它。
死锁
// synchronized嵌套发生死锁,一般不建议这么写
package Thread; public class DeahLock { public static void main(String[] args) { Object a=new Object(); Object b=new Object(); Thread a1=new MyThread1(a,b); Thread b1=new MyThread2(a,b); a1.setName("a1"); b1.setName("b1"); a1.start(); b1.start(); } } class MyThread1 extends Thread{ Object O1; Object O2; public MyThread1(Object a,Object b){ this.O1=a; this.O2=b; } public void run() { synchronized (O1){ try { Thread.sleep(1000); } catch (InterruptedException e) { throw new RuntimeException(e); } synchronized (O2){ } } } } class MyThread2 extends Thread{ Object O1; Object O2; public MyThread2(Object a,Object b){ this.O1=a; this.O2=b; } public void run() { synchronized (O2){ try { Thread.sleep(1000); } catch (InterruptedException e) { throw new RuntimeException(e); } synchronized (O1){ } } } }
9.1守护线程(后台线程)
java一共有两种线程,一个是守护,一个是用户线程。
具有代表性的:gc垃圾回收器。
守护线程特点:
一般守护线程是个死循环,用户线程结束则守护结束。
ps:主线程main方法是用户线程。
守护线程用在什么地方?
守护,偏后台
代码格式:
a.setDaemon(true);//将a线程对象设置成守护线程。
package Thread; public class ThreadText02 { public static void main(String[] args) { Thread a=new T(); a.setName("a"); a.setDaemon(true); a.start(); for (int i=0;i<10;i++) { try { Thread.sleep(1000); } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println(Thread.currentThread().getName()+"->"+i); } } } class T extends Thread{ int i=0;//当用户线程结束,守护线程自动终止。
public void run() { while (true) { i++; try { T.sleep(1000); } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println(Thread.currentThread().getName()+"->"+i); } } }
2.定时器
什么是定时器?
间隔特定时间,执行特定程序。
在实际开发中每隔一段时间执行一段程序是很常见的。
在java中可以采用多种方式实现:
1.使用sleep方法,设置睡眠时间,睡眠结束后醒来执行。
2.java类库中已经写好了定时器,使用java.until.Timer,可以直接使用
3.一般高级框架中都实现了定时,比如Spring。
Timer
schedule(定时任务对象(继承TimerTask)这里也可以用匿名抽象类,开始,间隔时间)
代码如下:
package Thread.ThreadSafe; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Timer; import java.util.TimerTask; public class TimerText01 { public static void main(String[] args) throws Exception{ Timer a=new Timer();//创建定时器 SimpleDateFormat s=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//定义日期格式 Date first=s.parse("2022-05-17 11:11:50");//解析字符串 a.schedule(new text(),first,1000*5);//定时任务间隔时间 } } class text extends TimerTask { public void run() { SimpleDateFormat s=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String f1=s.format(new Date()); System.out.println(f1+"完成备份"); } }
//间隔5秒。
3.实现线程的第三种方式:实现Callable接口
前两种是什么??
D:继承Thread和实现Runnable接口。
Callable接口有什么特点呢?
优点:它的线程可以返回一个值。前两种都是void型的。
缺点:如果要返回值的话,需要等待call运行结束返回值.get(),影响效率。
package Thread; import java.util.concurrent.Callable; import java.util.concurrent.FutureTask; public class CallableThreadText { public static void main(String[] args) throws Exception{ //第一步,创建一个“未来任务类对象”
//FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
FutureTask f=new FutureTask(new Callable() {//匿名内部类 //call方法就相当于run方法,只不过这个有返回值。 public Object call() throws Exception { System.out.println("call begin"); Thread.sleep(1000*5); int a=5,b=10; System.out.println("call over"); return a+b;//自动装箱变成Intger } }); Thread t=new Thread(f);//创建线程对象 t.start(); Object a1=f.get();//得到call的返回值,get方法会使main阻塞,call结束后main才能继续执行。 System.out.println(a1); } }
4.关于Object类中的wait和notify方法。(生产者和消费者模式!)
第一,wait和notify方法不是线程对象独有方法,是java中任何一个java对象都有的方法,因为这两方法是object类自带的。
wait方法和notify方法不是通过线程调用的,t.wait【×】t.notify【×】。
第二,wait()方法作用?
Object o=new Object ();
o.wait();
表示:
让正在o对象上的活动进入等待状态,无限等待,直到被唤醒,而sleep是线程特有方法,并是有限等待。
o.wait();方法调用,会让当前正在o对象上活动的线程进入等待状态。
第三,notify()方法作用?
Object o=new object();
o.notify();
表示:
唤醒正在o对象上等待的线程。
还有个notifyAll()方法,这是让在o上等待的线程全部唤醒。
生产者与消费者(生产者产一个,消费者消耗一个)
package Thread; import java.util.ArrayList; import java.util.List; public class ThreadText03 { public static void main(String[] args) { List list=new ArrayList(); Thread a1=new Thread(new Producer(list)); Thread b1=new Thread(new Consumer(list)); a1.setName("Producer"); b1.setName("consumer"); a1.start(); b1.start(); } } class Producer implements Runnable{ private List list; public Producer(List l){ this.list=l; } @Override public void run() { while (true) { synchronized (list){ if(list.size()>0) { try { list.wait(); } catch (InterruptedException e) { throw new RuntimeException(e); } } Object o=new Object(); list.add(o); System.out.println(Thread.currentThread().getName()+"->"+o); list.notifyAll(); } } } } class Consumer implements Runnable{ private List list; public Consumer(List i) { this.list=i; } @Override public void run() { while (true) { synchronized (list){ if(list.size()==0) { try { list.wait(); } catch (InterruptedException e) { throw new RuntimeException(e); } } Object o=new Object(); list.remove(0); System.out.println(Thread.currentThread().getName()+"->"+o); list.notifyAll(); } } } }
标签:Thread,void,Object,线程,new,多线程,public From: https://www.cnblogs.com/lengbo/p/17399761.html