目录
继承Thread类：
public class Tt extends Thread{ //继承thread类
@Override //重写run方法
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("1:"+i);
}
}
public static void main(String[] args) {
Tt tt= new Tt(); //创建一个新对象
tt.start(); //start方法开启线程
for (int i = 0; i < 20; i++) {
System.out.println("2:"+i);
}
}
}实现runnable接口：
public class Tt implements Runnable{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("1:"+i);
}
}
public static void main(String[] args) {
Tt tt = new Tt();
// Thread thread = new Thread(tt);
// thread.start();
new Thread(tt).start();
for (int i = 0; i < 20; i++) {
System.out.println("2:"+i);
}
}
}初实并发问题：
当多线程操作一个资源的情况下，线程不安全，数据紊乱。
（龟兔赛跑）：
package 练习;
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%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);
return true;
}
}
return false;
}
public static void main(String[] args) {
Race race = new Race();
new Thread(race,"兔子").start();
new Thread(race,"乌龟").start();
}
}
实现Callable：（了解即可）
实现接口，需要返回值。
重写call方法。
创建执行服务。
提交执行。
获取结果
关闭服务
public static void main(String[] args) throws ExecutionException, InterruptedException { Th th1 = new Th(); ExecutorService ser= Executors.newFixedThreadPool(1); //创建执行服务 Future<Object> r1=ser.submit(th1); //提交执行 Object rs1=r1.get(); //获取结果 ser.shutdownNow(); //关闭服务 }
静态代理：
真实对象和对立对象都要实现同一个接口。
代理对象要代理真实对象。
package 练习;
public class jingtai {
public static void main(String[] args) {
You you = new You();
Wedding wedding = new Wedding(you);
wedding.Happy();
}
}
interface Marry{ //功能接口
void Happy();
}
class You implements Marry{
@Override
public void Happy() {
System.out.println("我要结婚了");
}
}
class Wedding implements Marry{
private Marry target;
public Wedding(Marry target){
this.target=target;
}
@Override
public void Happy() {
before();
this.target.Happy();
after();
}
private void after() {
System.out.println("之后");
}
private void before() {
System.out.println("之前");
}
}
Lamda表达式：
函数式接口的定义：
任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口
public interface Runnable{\ public abstract void run(); }
对于函数式接口，我们可以通过lambda表达式创建该接口的对象。
lambda推导过程：
package 练习2;
public class TestLambda {
// 3.静态内部类
static class Like2 implements TLike {
@Override
public void lambda() {
System.out.println("lambda2");
}
}
public static void main(String[] args) {
//4.局部内部类
class Like3 implements TLike {
@Override
public void lambda() {
System.out.println("lambda3");
}
}
TLike like = new Like();
like.lambda();
like = new Like2();
like.lambda();
like = new Like3();
like.lambda();
// 5.匿名内部类 没有类的接口 必须借助接口或者父类
like = new TLike() {
@Override
public void lambda() {
System.out.println("lambda4");
}
};
like.lambda();
// 6.用lambda
like = () -> {
System.out.println("lambda5");
};
like.lambda();
}
//1.定义一个函数式接口
interface TLike {
void lambda();
}
//2.实现类
static class Like implements TLike {
@Override
public void lambda() {
System.out.println("lambda");
}
}
}lambda有参构造：
局部内部类：new接口然后重写方法；
lambda：类 对象名=(参数)->{方法}
简化:类 对象名=参数->{方法}
简化：类 对象名=参数->方法 //前提代码单行可以。
线程状态：（五个状态）
new为新生状态，调用start为就绪状态（但不意味着立即执行），阻塞状态（sleep，wait或者同步锁），运行状态，死亡状态
线程停止
1.建议线程正常停止----》利用次数。不建议死循环
2.建议使用标志位----》设置一个标志位
3.不用使用stop或destory 等过时或者JDK 不建议使用的方法
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++);
}
}
//2.设置一个公开的方法停止线程，转换标志位
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 < 1000; i++) {
System.out.println("main" + i);
if (i == 900) {
//调用stop方法切换标志位，让线程停止
testStop.stop();
System.out.println("该线程停止了");
}
}
}
}