Java day22

java day22
线程、同步
多线程原理
package Demo1;
public class Demo01MainTherad {
public static void main(String[] args) {
proson p1 = new proson(“曾”);
p1.run();
proson p2 = new proson(“炟”);
p2.run();
}
}
package Demo1;
public class proson {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public proson(String name) {
this.name = name;
}
public proson() {
super();
}
public void run() {
for (int i =0;i<20;i++) {
System.out.println(name+"");
}
}
}
Thread类
API中该类中定义了有关线程的一些方法
public Thread() :分配一个新的线程对象
public Thread(String name) :分配一个指定名字的新的线程对象
public Thread(Runnable target) :分配一个带有指定目标新的线程对象
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字
创建线程方式
定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正 的线程对象
调用线程对象的start()方法来启动线程
package Demo1;
public class Demo01Thread {
public static void main(String[] args) {
MyThread mt =new MyThread();
mt.start();
for (int i =0;i<20;i++) {
System.out.println(“主线程:”+i);
if(i==10) {
System.out.println(0/0);
}
}
}
}
Thread和Runnable的区别
一个类继承Thread，不适合资源共享
实现Runnable接口比继承Thread类所具有的优势
适合多个相同的程序代码的线程去共享同一个资源
可以避免java中的单继承的局限性
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立
线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类
Thread
package demo02;
public class Demo01Thread {
public static void main(String[] args) {
MyThread mt =new MyThread();
mt.start();
new MyThread().start();
new MyThread().start();
new MyThread().start(); System.out.println(“main：”+Thread.currentThread().getName());
}
}
public class MyThreadName extends Thread {
public MyThreadName() {}
public MyThreadName(String name) {
super(name);
public void run() {;
System.out.println(“子:”+Thread.currentThread().getName());
}
}
Runnable
package demo02;
public class Demo02MyThreadSetName {
public static void main(String[] args) {
MyThreadName mt =new MyThreadName(“小钱”);
mt.start();
new MyThreadName(“旺财”).start();
}
}
Timed Waiting（计时等待）
一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态
package Demo3;
public class Dem03Sleep {
public static void main(String[] args) {
for(int i=0;i<60;i++) {
System.out.println(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

Runnable和runnable
package Demo04;
public class Demo04Runnable {
public static void main(String[] args) {
Runnablelmpl run =new Runnablelmpl();
Thread t=new Thread(new Runalelmpl2());
t.start();
for(int i=0;i<20;i++) {
System.out.println(Thread.currentThread().getName()+"–>"+i);
}
}
}
package Demo04;
public class Runnablelmpl implements Runnable {
@Override
public void run() {
for(int i=0;i<20;i++) {
System.out.println(Thread.currentThread().getName()+"–>"+i);
}
}
}
线程安全
有多个线程在同时运行，而这些线程可能会同时运行这段代码
程序每次运行结果和单线程运行的结果是一样 的，而且其他的变量的值也和预期的是一样的，就是线程安全的
package demo05;
public class Demo01Ticket {
public static void main(String[] args) {
Runnablempl run =new Runnablempl();
Thread t0= new Thread(run);
Thread t1= new Thread(run);
Thread t2= new Thread(run);
t0.start();
t1.start();
t2.start();
}
}
改整
package demo05;
public class Demo01Ticket {
public static void main(String[] args) {
Runnablempl run =new Runnablempl();
Thread t0= new Thread(run);
Thread t1= new Thread(run);
Thread t2= new Thread(run);
t0.start();
t1.start();
t2.start();
}
}

2020080605024