Java-Multithread-Parallelitätsprobleme, die durch den Erhalt des WeChat-Zugriffstokens verursacht werden

Hintergrund:

access_token ist das weltweit eindeutige Ticket des offiziellen Kontos. Das access_token ist erforderlich, wenn das offizielle Konto jede Schnittstelle aufruft. Entwickler müssen es ordnungsgemäß speichern. Für die Speicherung des access_token müssen mindestens 512 Zeichen Platz reserviert werden. Die Gültigkeitsdauer von access_token beträgt derzeit 2 Stunden und muss regelmäßig aktualisiert werden. Wiederholte Erfassung führt dazu, dass das letzte access_token ungültig wird.

1、为了保密appsecrect，第三方需要一个access_token获取和刷新的中控服务器。而其他业务逻辑服务器所使用的access_token均来自于该中控服务器，不应该各自去刷新，否则会造成access_token覆盖而影响业务；
2、目前access_token的有效期通过返回的expire_in来传达，目前是7200秒之内的值。中控服务器需要根据这个有效时间提前去刷新新access_token。在刷新过程中，中控服务器对外输出的依然是老access_token，此时公众平台后台会保证在刷新短时间内，新老access_token都可用，这保证了第三方业务的平滑过渡；
3、access_token的有效时间可能会在未来有调整，所以中控服务器不仅需要内部定时主动刷新，还需要提供被动刷新access_token的接口，这样便于业务服务器在API调用获知access_token已超时的情况下，可以触发access_token的刷新流程。

简单起见，使用一个随servlet容器一起启动的servlet来实现获取access_token的功能，具体为：因为该servlet随着web容器而启动，在该servlet的init方法中触发一个线程来获得access_token，该线程是一个无线循环的线程，每隔2个小时刷新一次access_token。相关代码如下：
：

public class InitServlet extends HttpServlet 
{
	private static final long serialVersionUID = 1L;

	public void init(ServletConfig config) throws ServletException 
	{
		new Thread(new AccessTokenThread()).start();  
	}

}

2) Thread-Code :

public class AccessTokenThread implements Runnable 
{
	public static AccessToken accessToken;
	
	@Override
	public void run() 
	{
		while(true) 
		{
			try{
				AccessToken token = AccessTokenUtil.freshAccessToken();	// 从微信服务器刷新access_token
				if(token != null){
					accessToken = token;
				}else{
					System.out.println("get access_token failed------------------------------");
				}
			}catch(IOException e){
				e.printStackTrace();
			}
			
			try{
				if(null != accessToken){
					Thread.sleep((accessToken.getExpire_in() - 200) * 1000);	// 休眠7000秒
				}else{
					Thread.sleep(60 * 1000);	// 如果access_token为null，60秒后再获取
				}
			}catch(InterruptedException e){
				try{
					Thread.sleep(60 * 1000);
				}catch(InterruptedException e1){
					e1.printStackTrace();
				}
			}
		}
	}
}

3) AccessToken-Code :

public class AccessToken 
{
	private String access_token;
	private long expire_in;		// access_token有效时间，单位为妙
	
	public String getAccess_token() {
		return access_token;
	}
	public void setAccess_token(String access_token) {
		this.access_token = access_token;
	}
	public long getExpire_in() {
		return expire_in;
	}
	public void setExpire_in(long expire_in) {
		this.expire_in = expire_in;
	}
}

4) Servlet in web.xml-Konfiguration

  <servlet>
    <servlet-name>initServlet</servlet-name>
    <servlet-class>com.sinaapp.wx.servlet.InitServlet</servlet-class>
    <load-on-startup>0</load-on-startup>
  </servlet>

Da das initServlet „load-on-startup=0“ setzt, wird es garantiert vor allen anderen Servlets gestartet.

Andere Servlets, die access_token verwenden möchten, müssen nur AccessTokenThread.accessToken aufrufen.

Führt zu Multi-Thread-Parallelitätsproblemen :

1) Es scheint kein Problem mit der obigen Implementierung zu geben, aber wenn Sie darüber nachdenken Achten Sie darauf, dass das AccessToken in der AccessTokenThread-Klasse das Problem des gleichzeitigen Zugriffs hat. Es wird nur alle 2 Stunden von AccessTokenThread aktualisiert, aber es werden viele Threads zum Lesen vorhanden sein. Es ist ein typisches Szenario, in dem mehr gelesen und weniger geschrieben wird. und nur ein Thread schreibt. Da es gleichzeitige Lese- und Schreibvorgänge gibt, muss ein Problem mit dem obigen Code vorliegen.

Der einfachste Weg, sich das vorzustellen, ist die Verwendung von synchronisiert:

public class AccessTokenThread implements Runnable 
{
	private static AccessToken accessToken;
	
	@Override
	public void run() 
	{
		while(true) 
		{
			try{
				AccessToken token = AccessTokenUtil.freshAccessToken();	// 从微信服务器刷新access_token
				if(token != null){
					AccessTokenThread.setAccessToken(token);
				}else{
					System.out.println("get access_token failed");
				}
			}catch(IOException e){
				e.printStackTrace();
			}
			
			try{
				if(null != accessToken){
					Thread.sleep((accessToken.getExpire_in() - 200) * 1000);	// 休眠7000秒
				}else{
					Thread.sleep(60 * 1000);	// 如果access_token为null，60秒后再获取
				}
			}catch(InterruptedException e){
				try{
					Thread.sleep(60 * 1000);
				}catch(InterruptedException e1){
					e1.printStackTrace();
				}
			}
		}
	}

	public synchronized static AccessToken getAccessToken() {
		return accessToken;
	}

	private synchronized static void setAccessToken(AccessToken accessToken) {
		AccessTokenThread2.accessToken = accessToken;
	}
}

accessToken wird privat und setAccessToken wird ebenfalls privat ersetzt und hinzugefügt eine synchronisierte Methode für den Zugriff auf accessToken.

Ist es jetzt also perfekt? Gibt es kein Problem? Wenn man darüber nachdenkt, liegt das Problem immer noch in der Definition der AccessToken-Klasse. Sie stellt eine öffentliche Set-Methode bereit. Dann können alle Threads das von allen Threads gemeinsam genutzte AccessToken abrufen Ändern Sie seine Eigenschaften! ! ! ! Und das ist definitiv falsch und sollte nicht getan werden.

2) Lösung 1:

Wir lassen die AccessTokenThread.getAccessToken()-Methode eine Kopie des accessToken-Objekts zurückgeben, so dass die anderen Der Thread kann das accessToken in der AccessTokenThread-Klasse nicht ändern. Ändern Sie einfach die Methode AccessTokenThread.getAccessToken() wie folgt:

	public synchronized static AccessToken getAccessToken() {
		AccessToken at = new AccessToken();
		at.setAccess_token(accessToken.getAccess_token());		
		at.setExpire_in(accessToken.getExpire_in());
		return at;
	}

Sie können die Klonmethode auch in der AccessToken-Klasse implementieren. Die Prinzipien sind die gleichen . Natürlich ist setAccessToken auch privat geworden.

3) Lösung zwei :

Da wir nicht zulassen sollten, dass das AccessToken-Objekt geändert wird, warum definieren wir dann nicht accessToken als „Unveränderliche Objekte“? Die relevanten Änderungen sind wie folgt:

public class AccessToken 
{
	private final String access_token;
	private final long expire_in;		// access_token有效时间，单位为妙
	
	public AccessToken(String access_token, long expire_in)
	{
		this.access_token = access_token;
		this.expire_in = expire_in;
	}
	
	public String getAccess_token() {
		return access_token;
	}
	
	public long getExpire_in() {
		return expire_in;
	}
}

Wie oben gezeigt, sind alle Eigenschaften von AccessToken als endgültige Typen definiert und es werden nur Konstruktoren und Get-Methoden bereitgestellt . In diesem Fall können andere Threads es nicht ändern, nachdem sie das AccessToken-Objekt erhalten haben. Die Änderung erfordert, dass das in AccessTokenUtil.freshAccessToken() zurückgegebene AccessToken-Objekt nur über den Konstruktor mit Parametern erstellt werden kann. Gleichzeitig muss setAccessToken von AccessTokenThread auch in privat geändert werden, und getAccessToken muss keine Kopie zurückgeben.

Beachten Sie, dass unveränderliche Objekte die folgenden drei Bedingungen erfüllen müssen:

a) Der Status des Objekts kann nach seiner Erstellung nicht geändert werden;

b) Alle Felder des Das Objekt ist vom endgültigen Typ. Lösung 3

：

Gibt es eine andere bessere, perfektere und effizientere Methode? Lassen Sie es uns analysieren. In Lösung zwei gibt AccessTokenUtil.freshAccessToken() ein unveränderliches Objekt zurück und ruft dann die private AccessTokenThread.setAccessToken(AccessToken accessToken)-Methode auf, um den Wert zuzuweisen. Welche Rolle spielt die synchronisierte Synchronisation bei dieser Methode? Da das Objekt unveränderlich ist und nur ein Thread die setAccessToken-Methode aufrufen kann, spielt die Synchronisierung hier keine Rolle beim „gegenseitigen Ausschluss“ (da nur ein Thread es ändern kann), sondern nur bei der Gewährleistung der „Sichtbarkeit“. Für andere Threads sichtbar, dh andere Threads können auf das neueste accessToken-Objekt zugreifen. Um die „Sichtbarkeit“ zu gewährleisten, kann flüchtig verwendet werden, daher sollte eine Synchronisierung hier nicht erforderlich sein. Wir verwenden flüchtig, um es zu ersetzen. Der relevante geänderte Code lautet wie folgt:

Sie können ihn auch so ändern:

public class AccessTokenThread implements Runnable 
{
	private static volatile AccessToken accessToken;
	
	@Override
	public void run() 
	{
		while(true) 
		{
			try{
				AccessToken token = AccessTokenUtil.freshAccessToken();	// 从微信服务器刷新access_token
				if(token != null){
					AccessTokenThread2.setAccessToken(token);
				}else{
					System.out.println("get access_token failed");
				}
			}catch(IOException e){
				e.printStackTrace();
			}
			
			try{
				if(null != accessToken){
					Thread.sleep((accessToken.getExpire_in() - 200) * 1000);	// 休眠7000秒
				}else{
					Thread.sleep(60 * 1000);	// 如果access_token为null，60秒后再获取
				}
			}catch(InterruptedException e){
				try{
					Thread.sleep(60 * 1000);
				}catch(InterruptedException e1){
					e1.printStackTrace();
				}
			}
		}
	}

	private static void setAccessToken(AccessToken accessToken) {
		AccessTokenThread2.accessToken = accessToken;
	}
        public static AccessToken getAccessToken() {
               return accessToken;
        }
}

Du kannst es auch so ändern:

public class AccessTokenThread implements Runnable 
{
	private static volatile AccessToken accessToken;
	
	@Override
	public void run() 
	{
		while(true) 
		{
			try{
				AccessToken token = AccessTokenUtil.freshAccessToken();	// 从微信服务器刷新access_token
				if(token != null){
					accessToken = token;
				}else{
					System.out.println("get access_token failed");
				}
			}catch(IOException e){
				e.printStackTrace();
			}
			
			try{
				if(null != accessToken){
					Thread.sleep((accessToken.getExpire_in() - 200) * 1000);	// 休眠7000秒
				}else{
					Thread.sleep(60 * 1000);	// 如果access_token为null，60秒后再获取
				}
			}catch(InterruptedException e){
				try{
					Thread.sleep(60 * 1000);
				}catch(InterruptedException e1){
					e1.printStackTrace();
				}
			}
		}
	}

	public static AccessToken getAccessToken() {
		return accessToken;
	}
}

accesToken变成了public，可以直接是一个AccessTokenThread.accessToken来访问。但是为了后期维护，最好还是不要改成public.

其实这个问题的关键是：在多线程并发访问的环境中如何正确的发布一个共享对象。

其实我们也可以使用Executors.newScheduledThreadPool来搞定：

public class InitServlet2 extends HttpServlet 
{    private static final long serialVersionUID = 1L;    public void init(ServletConfig config) throws ServletException 
    {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        executor.scheduleAtFixedRate(new AccessTokenRunnable(), 0, 7200-200, TimeUnit.SECONDS);
    }
}

public class AccessTokenRunnable implements Runnable 
{    private static volatile AccessToken accessToken;
    
    @Override    public void run() 
    {        try{
            AccessToken token = AccessTokenUtil.freshAccessToken();    // 从微信服务器刷新access_token
            if(token != null){
                accessToken = token;
            }else{
                System.out.println("get access_token failed");
            }
        }catch(IOException e){
            e.printStackTrace();
        }
    }    public static AccessToken getAccessToken() 
    {        while(accessToken == null){            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }        return accessToken;
    }
    
}

获取accessToken方式变成了：AccessTokenRunnable.getAccessToken();

 更多由获取微信access_token引出的Java多线程并发问题相关文章请关注PHP中文网！