一、线程
1、线程的创建
多线程：多任务多条路径多个顺序流同时执行就是多线程。
线程优点：提高效率，同时执行
缺点：复杂
多线程的创建方式：
继承Thread类，重写run()方法，run方法中定义多线程的线程体
实现Runnable接口，重写run（）方法（推荐使用）
避免单继承的局限性
实现资源共享
实现Callable接口，重写call方法
ublic class ThreadTest extends Thread {
@Override
public void run() {
super.run();
for(int i=0;i<10;i++) {
System.out.println("v");
try {
Thread.sleep(3);//线程睡眠指定时间
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public static void main(String[] args) {
ThreadTest thread = new ThreadTest();
thread.start();//开启多线程
for(int i=0;i<10;i++) {
System.out.println("a");
try {
Thread.sleep(3);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
2、线程状态
新生状态：new 创建一个线程的时候
就绪状态:start(),线程会进入就绪队列，等待CPU的调度
运行状态：CPU调用分配时间片给线程，线程就会运行
阻塞状态：sleep()....
终止状态：线程结束了
一个线程一旦进入阻塞状态，阻塞解除之后，不会马上恢复运行，会恢复到就绪状态,等待CPU的调度；
一个线程一旦进入终止状态，再也不会恢复；
1.线程如何进入就绪状态：
start()
阻塞状态接除
线程切换，被切换的线程会恢复就绪状态
yield() 礼让线程
2.线程进入阻塞状态的方式
sleep()
wait()
jojin
3.控制一个线程终止
stop()
通过表示判断
正常执行结束
sleep():线程睡眠，模拟网络延迟，让出CPU的资源，不会让出对象的锁（抱着资源睡觉），指定休息多少毫秒；
yield()：礼让线程，让出CPU的资源，恢复到就绪状态
join():插队线程
getState():获取某个线程的状态
线程优先级：提高先执行的概率（1~10优先级依次变大，默认为5）
setPriority(int newPriority)：改变线程的优先级
getPriority():返回线程的优先级
public class StateTest2 implements Runnable {
public static void main(String[] args) {
StateTest2 sta = new StateTest2();
new Thread(sta,"B").start();;
}
@Override
public void run() {
while(true) {
Thread thread = new Thread(()->{
System.out.println("插队了。。。");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
});
thread.start();
try {
thread.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"开始执行");
thread.yield();
System.out.println(Thread.currentThread().getName()+"结束执行");
}
}
}
3、线程安全
多线程同时操作同一份资源才可能会出现线程不安全问题，需要控制安全
同步锁：synchronized
同步方法：在方法上使用synchronized修饰
成员方法，相当于锁this,代码范围为方法
静态方法，相当于锁类（类的class对象），代码范围为方法
同步块：synchronized(锁的内容){同步的代码范围}
锁内容：this、类.class、资源（成员变量）
锁范围: {}中代码范围
注意：
锁范围太大，效率低
锁范围太小，效率高
锁不变的内容
public class SynchronizedTest implements Runnable{
Ticket ticket=new Ticket();
public static void main(String[] args) {
SynchronizedTest s=new SynchronizedTest();
Thread t1=new Thread(s,"A");
Thread t2=new Thread(s,"B");
Thread t3=new Thread(s,"C");
t1.start();
t2.start();
t3.start();
}
@Override
public void run() {
while(true) {
// synchronized(SynchronizedTest.class) {
// synchronized(this) {
synchronized(ticket) {
if(ticket.num<=0){
break;
}
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"买了第"+ticket.num--+"张票");
}
}
}
}
class Ticket{
int num=100;
}
4、线程通信
生产者消费者模式
wait():等待，进入这个对象的等待池中进行等待，等待被唤醒wait会让出CPU的资源，并进行释放对象的锁
notify():唤醒，notifyAll()，唤醒对象等待池中的线程，处于可运行的状态，但是需要满足同步要求并被CPU调度才能执行
要求:使用在一个同步环境下，同步一个相同的对象才行
public class StreetTest {
public static void main(String[] args) {
Street street = new Street();
new Thread(new Person(street)).start();
new Thread(new Car(street)).start();
}
}
class Street{
boolean light=true;//灯亮
public synchronized void prson() {
while(true) {
if(light==false){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}else {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
light=false;
System.out.println("person.....");
this.notify();
}
}
}
public synchronized void car() {
while(true) {
if(light==true){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}else {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
light=true;
System.out.println("car.....");
this.notify();
}
}
}
}
class Person implements Runnable{
Street street;
public Person(Street street) {
super();
this.street = street;
}
@Override
public void run() {
// TODO Auto-generated method stub
street.prson();
}
}
class Car implements Runnable{
Street street;
public Car(Street street) {
this.street = street;
}
@Override
public void run() {
// TODO Auto-generated method stub
street.car();
}
}
5、网络安全
IP:定位网络上的节点
ip分类：ipv4 32位 ipv6 128位
特殊ip:
非注册ip:供组织内部使用(192.168.0.0~192.168.255.255)
本地ip：127.0.0.1
端口：区分软件 InetSocketAddress（0~65535之间的整数,2个字节）
自定义端口号推荐使用8000以上，统一协议下端口号不能冲突8000以内的预留端口号；（80：http、8080：tomcat、3306：mysql、1521：oracle）
url:统一资源定位符
传输层协议:
标准,规范,协议
udp : 非面向连接 协议简单,开销小,不安全 大小有限制
tcp : 基于连接 3次握手 协议复杂,开销大,效率低 安全 大小没有限制
public static void main(String[] args) throws UnknownHostException {
//static InetAddress getLocalHost() 返回本地主机的地址。
InetAddress in1=InetAddress.getLocalHost();
System.out.println(in1); //AB-201905250842/192.168.3.105
//static InetAddress getByName(String host) 决定了IP地址的主机,主机的名字。
InetAddress in2=InetAddress.getByName("www.shsxt.com");
System.out.println(in2);
//InetSocketAddress(String hostname, int port)创建一个套接字地址的主机名和端口号。
InetSocketAddress in3=new InetSocketAddress("localhost",8888);
System.out.println(in3);
System.out.println(in3.getPort());
System.out.println(in3.getAddress());
System.out.println(in3.getHostName());
}
扫一扫
1648
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
