Erstellen des Singleton-Entwurfsmuster in PHP5
https://stackoverflow.com/questions/203336
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Wie würde man eine Singleton-Klasse PHP5 Klassen erstellen?
Lösung
/**
* Singleton class
*
*/
final class UserFactory
{
/**
* Call this method to get singleton
*
* @return UserFactory
*/
public static function Instance()
{
static $inst = null;
if ($inst === null) {
$inst = new UserFactory();
}
return $inst;
}
/**
* Private ctor so nobody else can instantiate it
*
*/
private function __construct()
{
}
}
So verwenden:
$fact = UserFactory::Instance();
$fact2 = UserFactory::Instance();
$fact == $fact2;
Aber:
$fact = new UserFactory()
Wirft einen Fehler.
Siehe http://php.net/manual/en/language.variables.scope.php#language.variables.scope.static statische Variable Bereiche zu verstehen und warum Einstellung static $inst = null; funktioniert.
Andere Tipps
PHP 5.3 ermöglicht die Erstellung einer vererbbaren Singleton Klasse über späte statische Bindung:
class Singleton
{
protected static $instance = null;
protected function __construct()
{
//Thou shalt not construct that which is unconstructable!
}
protected function __clone()
{
//Me not like clones! Me smash clones!
}
public static function getInstance()
{
if (!isset(static::$instance)) {
static::$instance = new static;
}
return static::$instance;
}
}
Dies löst das Problem, dass vor PHP 5.3 jede Klasse, die einen Singleton verlängert würde, anstatt seine eigene Instanz der übergeordneten Klasse erzeugen.
Jetzt können Sie tun:
class Foobar extends Singleton {};
$foo = Foobar::getInstance();
Und $ foo wird eine Instanz von Foobar statt eine Instanz von Singleton sein.
Leider Inwdr Antwort bricht, wenn es mehrere Unterklassen.
Hier ist eine richtige vererbbar Singleton Basisklasse.
class Singleton
{
private static $instances = array();
protected function __construct() {}
protected function __clone() {}
public function __wakeup()
{
throw new Exception("Cannot unserialize singleton");
}
public static function getInstance()
{
$cls = get_called_class(); // late-static-bound class name
if (!isset(self::$instances[$cls])) {
self::$instances[$cls] = new static;
}
return self::$instances[$cls];
}
}
Testcode:
class Foo extends Singleton {}
class Bar extends Singleton {}
echo get_class(Foo::getInstance()) . "\n";
echo get_class(Bar::getInstance()) . "\n";
The Real One und Moderne Weg Singleton Muster zu machen, ist:
<?php
/**
* Singleton Pattern.
*
* Modern implementation.
*/
class Singleton
{
/**
* Call this method to get singleton
*/
public static function instance()
{
static $instance = false;
if( $instance === false )
{
// Late static binding (PHP 5.3+)
$instance = new static();
}
return $instance;
}
/**
* Make constructor private, so nobody can call "new Class".
*/
private function __construct() {}
/**
* Make clone magic method private, so nobody can clone instance.
*/
private function __clone() {}
/**
* Make sleep magic method private, so nobody can serialize instance.
*/
private function __sleep() {}
/**
* Make wakeup magic method private, so nobody can unserialize instance.
*/
private function __wakeup() {}
}
So, jetzt können Sie es mögen verwenden.
<?php
/**
* Database.
*
* Inherited from Singleton, so it's now got singleton behavior.
*/
class Database extends Singleton {
protected $label;
/**
* Example of that singleton is working correctly.
*/
public function setLabel($label)
{
$this->label = $label;
}
public function getLabel()
{
return $this->label;
}
}
// create first instance
$database = Database::instance();
$database->setLabel('Abraham');
echo $database->getLabel() . PHP_EOL;
// now try to create other instance as well
$other_db = Database::instance();
echo $other_db->getLabel() . PHP_EOL; // Abraham
$other_db->setLabel('Priler');
echo $database->getLabel() . PHP_EOL; // Priler
echo $other_db->getLabel() . PHP_EOL; // Priler
Wie Sie sehen diese Erkenntnis ist viel flexibler.
Sie sollten wahrscheinlich eine private __clone () -Methode nicht zulassen Klonen einer Instanz hinzufügen.
private function __clone() {}
Wenn Sie nicht enthalten diese Methode die folgenden wird möglich
$inst1=UserFactory::Instance(); // to stick with the example provided above
$inst2=clone $inst1;
$inst1 jetzt == $inst2 -. Sie nicht dieselbe Instanz sind nicht mehr
<?php
/**
* Singleton patter in php
**/
trait SingletonTrait {
protected static $inst = null;
/**
* call this method to get instance
**/
public static function getInstance(){
if (static::$inst === null){
static::$inst = new static();
}
return static::$inst;
}
/**
* protected to prevent clonning
**/
protected function __clone(){
}
/**
* protected so no one else can instance it
**/
protected function __construct(){
}
}
zu verwenden:
/**
* example of class definitions using SingletonTrait
*/
class DBFactory {
/**
* we are adding the trait here
**/
use SingletonTrait;
/**
* This class will have a single db connection as an example
**/
protected $db;
/**
* as an example we will create a PDO connection
**/
protected function __construct(){
$this->db =
new PDO('mysql:dbname=foodb;port=3305;host=127.0.0.1','foouser','foopass');
}
}
class DBFactoryChild extends DBFactory {
/**
* we repeating the inst so that it will differentiate it
* from UserFactory singleton
**/
protected static $inst = null;
}
/**
* example of instanciating the classes
*/
$uf0 = DBFactoryChild::getInstance();
var_dump($uf0);
$uf1 = DBFactory::getInstance();
var_dump($uf1);
echo $uf0 === $uf1;
respose:
object(DBFactoryChild)#1 (0) {
}
object(DBFactory)#2 (0) {
}
Wenn Sie mit PHP 5.4: Merkmal seine Option, so dass Sie nicht in der Vererbungshierarchie, um verschwenden müssen, um die haben Singleton-Muster
und auch feststellen, dass, ob Sie mit Merkmale oder erweitert Singleton Klasse ein lose war Ende Singleton von Kinderklassen zu erstellen, wenn Sie die folgende Codezeile nicht hinzufügen:
protected static $inst = null;
in der untergeordneten Klasse
das unerwartete Ergebnis wird sein:
object(DBFactoryChild)#1 (0) {
}
object(DBFactoryChild)#1 (0) {
}
protected static $_instance;
public static function getInstance()
{
if(is_null(self::$_instance))
{
self::$_instance = new self();
}
return self::$_instance;
}
Dieser Code kann für jede Klasse anwenden um seine Klassennamen ohne Pflege.
Unterstützt mehrere Objekte mit 1 Zeile pro Klasse:
Diese Methode erzwingen Singletons für jede Klasse Sie möchten, al Sie tun müssen, ist 1 hinzufügen Methode zur Klasse Sie einen Singleton machen wollen, und dies wird es für Sie tun.
Dies auch Objekte in einer „SingleTonBase“ Klasse speichert, so dass Sie alle Ihre Objekte debuggen können, die Sie in Ihrem System verwendet haben, indem sie die SingleTonBase Objekte Rekursion.
Erstellen Sie eine Datei mit dem Namen SingletonBase.php und es in Wurzel des Skripts!
Der Code ist
abstract class SingletonBase
{
private static $storage = array();
public static function Singleton($class)
{
if(in_array($class,self::$storage))
{
return self::$storage[$class];
}
return self::$storage[$class] = new $class();
}
public static function storage()
{
return self::$storage;
}
}
Dann gilt für jede Klasse, die Sie einen Singleton machen wollen nur diese kleine einzelne Methode hinzuzufügen.
public static function Singleton()
{
return SingletonBase::Singleton(get_class());
}
Hier ist ein kleines Beispiel:
include 'libraries/SingletonBase.resource.php';
class Database
{
//Add that singleton function.
public static function Singleton()
{
return SingletonBase::Singleton(get_class());
}
public function run()
{
echo 'running...';
}
}
$Database = Database::Singleton();
$Database->run();
Und Sie können nur diese Singleton-Funktion in jeder Klasse hinzufügen, die Sie haben, und es wird nur 1 Instanz pro Klasse.
Hinweis: Sie sollten immer die __construct privat machen den Einsatz neuer Klasse zu beseitigen (); instantiations.
class Database{
//variable to hold db connection
private $db;
//note we used static variable,beacuse an instance cannot be used to refer this
public static $instance;
//note constructor is private so that classcannot be instantiated
private function __construct(){
//code connect to database
}
//to prevent loop hole in PHP so that the class cannot be cloned
private function __clone() {}
//used static function so that, this can be called from other classes
public static function getInstance(){
if( !(self::$instance instanceof self) ){
self::$instance = new self();
}
return self::$instance;
}
public function query($sql){
//code to run the query
}
}
Access the method getInstance using
$db = Singleton::getInstance();
$db->query();
Sie brauchen nicht wirklich Singleton-Muster zu verwenden, weil es betrachtet ist ein Antipattern zu sein. Grundsätzlich gibt es eine Menge Gründe, um nicht dieses Muster überhaupt zu realisieren. Lesen Sie diese mit beginnen: Best Practice auf PHP Singletons Klassen .
Wenn nach allem, was Sie noch denken, Sie brauchen Singleton-Muster verwenden, dann könnten wir eine Klasse schreiben, die es uns ermöglichen, Singleton Funktionalität zu erhalten durch unsere SingletonClassVendor abstrakte Klasse erweitert.
Das ist, was ich kam mit, dieses Problem zu lösen.
<?php
namespace wl;
/**
* @author DevWL
* @dosc allows only one instance for each extending class.
* it acts a litle bit as registry from the SingletonClassVendor abstract class point of view
* but it provides a valid singleton behaviour for its children classes
* Be aware, the singleton pattern is consider to be an anti-pattern
* mostly because it can be hard to debug and it comes with some limitations.
* In most cases you do not need to use singleton pattern
* so take a longer moment to think about it before you use it.
*/
abstract class SingletonClassVendor
{
/**
* holds an single instance of the child class
*
* @var array of objects
*/
protected static $instance = [];
/**
* @desc provides a single slot to hold an instance interchanble between all child classes.
* @return object
*/
public static final function getInstance(){
$class = get_called_class(); // or get_class(new static());
if(!isset(self::$instance[$class]) || !self::$instance[$class] instanceof $class){
self::$instance[$class] = new static(); // create and instance of child class which extends Singleton super class
echo "new ". $class . PHP_EOL; // remove this line after testing
return self::$instance[$class]; // remove this line after testing
}
echo "old ". $class . PHP_EOL; // remove this line after testing
return static::$instance[$class];
}
/**
* Make constructor abstract to force protected implementation of the __constructor() method, so that nobody can call directly "new Class()".
*/
abstract protected function __construct();
/**
* Make clone magic method private, so nobody can clone instance.
*/
private function __clone() {}
/**
* Make sleep magic method private, so nobody can serialize instance.
*/
private function __sleep() {}
/**
* Make wakeup magic method private, so nobody can unserialize instance.
*/
private function __wakeup() {}
}
Anwendungsbeispiel:
/**
* EXAMPLE
*/
/**
* @example 1 - Database class by extending SingletonClassVendor abstract class becomes fully functional singleton
* __constructor must be set to protected becaouse:
* 1 to allow instansiation from parent class
* 2 to prevent direct instanciation of object with "new" keword.
* 3 to meet requierments of SingletonClassVendor abstract class
*/
class Database extends SingletonClassVendor
{
public $type = "SomeClass";
protected function __construct(){
echo "DDDDDDDDD". PHP_EOL; // remove this line after testing
}
}
/**
* @example 2 - Config ...
*/
class Config extends SingletonClassVendor
{
public $name = "Config";
protected function __construct(){
echo "CCCCCCCCCC" . PHP_EOL; // remove this line after testing
}
}
Nur um zu beweisen, dass es wie erwartet funktioniert:
/**
* TESTING
*/
$bd1 = Database::getInstance(); // new
$bd2 = Database::getInstance(); // old
$bd3 = Config::getInstance(); // new
$bd4 = Config::getInstance(); // old
$bd5 = Config::getInstance(); // old
$bd6 = Database::getInstance(); // old
$bd7 = Database::getInstance(); // old
$bd8 = Config::getInstance(); // old
echo PHP_EOL."COMPARE ALL DATABASE INSTANCES".PHP_EOL;
var_dump($bd1);
echo '$bd1 === $bd2' . ($bd1 === $bd2)? ' TRUE' . PHP_EOL: ' FALSE' . PHP_EOL; // TRUE
echo '$bd2 === $bd6' . ($bd2 === $bd6)? ' TRUE' . PHP_EOL: ' FALSE' . PHP_EOL; // TRUE
echo '$bd6 === $bd7' . ($bd6 === $bd7)? ' TRUE' . PHP_EOL: ' FALSE' . PHP_EOL; // TRUE
echo PHP_EOL;
echo PHP_EOL."COMPARE ALL CONFIG INSTANCES". PHP_EOL;
var_dump($bd3);
echo '$bd3 === $bd4' . ($bd3 === $bd4)? ' TRUE' . PHP_EOL: ' FALSE' . PHP_EOL; // TRUE
echo '$bd4 === $bd5' . ($bd4 === $bd5)? ' TRUE' . PHP_EOL: ' FALSE' . PHP_EOL; // TRUE
echo '$bd5 === $bd8' . ($bd5 === $bd8)? ' TRUE' . PHP_EOL: ' FALSE' . PHP_EOL; // TRUE
All Komplexität ( „späte statische Bindung“ ... harumph) ist für mich einfach ein Zeichen des gebrochenen Objekt / Klassenmodell von PHP. Wenn Klassenobjekte waren erstklassige Objekte (siehe Python), dann „$ _instance“ wäre eine Klasse Instanz Variable - ein Mitglied des Klassenobjekts, im Gegensatz zu einem Mitglied / Eigentum seiner Instanzen und auch, wie durch seine Nachkommen geteilt gegenüber. In der Smalltalk-Welt, das ist der Unterschied zwischen einem „Klassenvariable“ und „Klasseninstanzvariable“.
In PHP, sieht es für mich, als ob wir die Führung zu Herzen nehmen müssen, die Muster eine Führung auf das Schreiben von Code sind - wir vielleicht über eine Singleton Vorlage denken könnte, sondern versuchen, Code zu schreiben, die von einem tatsächlichen erbt " Singleton“Klasse sieht fehlgeleiteten für PHP (obwohl ich einige findige Seele sollte ein geeignetes SVN Stichwort erstellen könnte).
Ich werde weiterhin nur jeden Singleton Code getrennt, eine gemeinsame Vorlage.
Beachten Sie, dass ich absolut OUT dem Aufenthalt Singletons-sind-böse Diskussion, das Leben zu kurz ist.
Ich weiß, dass dies wahrscheinlich wird eine unnötige Flamme Krieg führen, aber ich kann sehen, wie Sie mehr als eine Datenbankverbindung wünschen könnte, so würde ich den Punkt zugeben, dass Singletons nicht die beste Lösung für das sein könnte ... aber gibt es andere Verwendungen des Singleton-Musters, das ich sehr nützlich finden.
Hier ist ein Beispiel: Ich beschloss, meine eigene MVC und Template-Engine zu rollen, weil ich etwas wirklich leichte wollte. die Daten, die ich möchte jedoch zum Anzeigen enthält viele spezielle mathematische Zeichen wie ≥ und μ und was Sie haben ... Die Daten werden als die tatsächlichen UTF-8-Zeichen in der Datenbank gespeichert wird, statt vor dem HTML-codiert, weil meine app können andere Formate liefern wie PDF und CSV zusätzlich zu HTML. Der geeignete Ort für HTML-Format ist in der Vorlage ( „Ansicht“, wenn man so will), die für die Darstellung dieser Seite Abschnitts (Snippet) verantwortlich ist. Ich möchte, dass sie in die entsprechenden HTML-Entitäten konvertieren, aber PHPs get_html_translation_table () -Funktion ist nicht super schnell. Es macht mehr Sinn, die Daten einmal und speichern als Array abzurufen, verfügbar zu machen für alle zu nutzen. Hier ist ein Beispiel Ich klopfte zusammen, um die Geschwindigkeit zu testen. Vermutlich würde dies unabhängig davon funktionieren, ob die anderen Methoden, die Sie (nach dem Aufstehen der Instanz) verwenden waren statisch oder nicht.
class EncodeHTMLEntities {
private static $instance = null;//stores the instance of self
private $r = null;//array of chars elligalbe for replacement
private function __clone(){
}//disable cloning, no reason to clone
private function __construct()
{
$allEntities = get_html_translation_table(HTML_ENTITIES, ENT_NOQUOTES);
$specialEntities = get_html_translation_table(HTML_SPECIALCHARS, ENT_NOQUOTES);
$this->r = array_diff($allEntities, $specialEntities);
}
public static function replace($string)
{
if(!(self::$instance instanceof self) ){
self::$instance = new self();
}
return strtr($string, self::$instance->r);
}
}
//test one million encodings of a string
$start = microtime(true);
for($x=0; $x<1000000; $x++){
$dump = EncodeHTMLEntities::replace("Reference method for diagnosis of CDAD, but clinical usefulness limited due to extended turnaround time (≥96 hrs)");
}
$end = microtime(true);
echo "Run time: ".($end-$start)." seconds using singleton\n";
//now repeat the same without using singleton
$start = microtime(true);
for($x=0; $x<1000000; $x++){
$allEntities = get_html_translation_table(HTML_ENTITIES, ENT_NOQUOTES);
$specialEntities = get_html_translation_table(HTML_SPECIALCHARS, ENT_NOQUOTES);
$r = array_diff($allEntities, $specialEntities);
$dump = strtr("Reference method for diagnosis of CDAD, but clinical usefulness limited due to extended turnaround time (≥96 hrs)", $r);
}
$end = microtime(true);
echo "Run time: ".($end-$start)." seconds without using singleton";
Im Grunde sah ich typische Ergebnisse wie folgt aus:
php test.php Run time: 27.842966794968 seconds using singleton Run time: 237.78191494942 seconds without using singleton
So, während ich bin sicherlich kein Experte, ich sehe nicht eine bequeme und zuverlässige Weise den Aufwand für die langsamen Anruf für eine Art von Daten zu reduzieren, während es super einfach (einzige Zeile Code zu tun, was Sie brauchen). Zugegeben mein Beispiel hat nur eine nützliche Methode, und deshalb ist nicht besser als eine global definierte Funktion, aber sobald man zwei Methoden hat, Sie gehen zu einer Gruppe wollen, dass sie zusammen, nicht wahr? Bin ich weg Basis?
Auch ziehe ich es Beispiele, die tatsächlich etwas tun, denn manchmal ist es schwer zu visualisieren, wenn ein Beispiel Aussagen enthält wie „// etwas Nützliches tun hier“, die ich die ganze Zeit sehen, wenn für Tutorien zu suchen.
Wie auch immer, würde ich Feedback oder Kommentare lieben, warum ein Singleton für diese Art der Sache mit schädlich ist (oder zu kompliziert).
In diesem Artikel Thema recht ausführlich: http://www.phptherightway.com/pages/Design-Patterns.html#singleton
Beachten Sie Folgendes:
- Der Konstruktor
__construct()alsprotectederklärt eine neue Instanz außerhalb der Klasse über dennewOperator zu verhindern, zu schaffen.- Die magische Methode
__clone()alsprivateerklärt Klonen von einer Instanz der Klasse über dencloneOperator zu verhindern.- Die magische Methode
__wakeup()alsprivateerklärt deserialisieren einer Instanz der Klasse über die globale Funktion zu verhindernunserialize().- Eine neue Instanz wird über späte statischen erstellt in der statischen Erstellungsmethode
getInstance()mit dem Schlüsselwortstaticverbindlich. Diese ermöglicht die Subklassen desclass Singletonim Beispiel.
habe ich geschrieben lange zurück dachte, hier zu teilen
class SingletonDesignPattern {
//just for demo there will be only one instance
private static $instanceCount =0;
//create the private instance variable
private static $myInstance=null;
//make constructor private so no one create object using new Keyword
private function __construct(){}
//no one clone the object
private function __clone(){}
//avoid serialazation
public function __wakeup(){}
//ony one way to create object
public static function getInstance(){
if(self::$myInstance==null){
self::$myInstance=new SingletonDesignPattern();
self::$instanceCount++;
}
return self::$myInstance;
}
public static function getInstanceCount(){
return self::$instanceCount;
}
}
//now lets play with singleton design pattern
$instance = SingletonDesignPattern::getInstance();
$instance = SingletonDesignPattern::getInstance();
$instance = SingletonDesignPattern::getInstance();
$instance = SingletonDesignPattern::getInstance();
echo "number of instances: ".SingletonDesignPattern::getInstanceCount();
ich mit der ersten Antwort zustimmen, aber ich würde auch die Klasse als endgültig erklären, so dass es nicht einen Singleton als Verlängerung gegen die Singletonmuster erweitert werden kann. Auch sollte die Instanzvariable privat sein, so dass es nicht direkt zugegriffen werden. Auch die __clone Methode privat machen, so dass Sie das Singleton-Objekt nicht klonen können.
Im Folgenden finden Sie einige Beispiel-Code.
/**
* Singleton class
*
*/
final class UserFactory
{
private static $_instance = null;
/**
* Private constructor
*
*/
private function __construct() {}
/**
* Private clone method
*
*/
private function __clone() {}
/**
* Call this method to get singleton
*
* @return UserFactory
*/
public static function getInstance()
{
if (self::$_instance === null) {
self::$_instance = new UserFactory();
}
return self::$_instance;
}
}
Beispiel Verwendung
$user_factory = UserFactory::getInstance();
Was hindert Sie daran, zu tun (was die Singletonmuster verletzen würde ..
Sie können das nicht!
$user_factory = UserFactory::$_instance;
class SecondUserFactory extends UserFactory { }
Dies sollte der richtige Weg von Singleton sein.
class Singleton {
private static $instance;
private $count = 0;
protected function __construct(){
}
public static function singleton(){
if (!isset(self::$instance)) {
self::$instance = new Singleton;
}
return self::$instance;
}
public function increment()
{
return $this->count++;
}
protected function __clone(){
}
protected function __wakeup(){
}
}
Ich mochte @ Jose-segura Methode Züge verwenden, aber nicht wie die Notwendigkeit, eine statische Variable auf Unterklassen zu definieren. Im Folgenden finden Sie eine Lösung, die es durch Caching die Instanzen in einer statischen lokalen Variablen auf die Factory-Methode durch Klassennamen indexiert vermeidet:
<?php
trait Singleton {
# Single point of entry for creating a new instance. For a given
# class always returns the same instance.
public static function instance(){
static $instances = array();
$class = get_called_class();
if( !isset($instances[$class]) ) $instances[$class] = new $class();
return $instances[$class];
}
# Kill traditional methods of creating new instances
protected function __clone() {}
protected function __construct() {}
}
Die Verwendung ist die gleiche wie @ jose-segura nur keine Notwendigkeit für die statische Variable in Unterklassen.
Datenbank-Klasse, die überprüft, ob es eine vorhandene Datenbankinstanz ist, wird es Vorinstanz zurück.
class Database {
public static $instance;
public static function getInstance(){
if(!isset(Database::$instance) ) {
Database::$instance = new Database();
}
return Database::$instance;
}
private function __cunstruct() {
/* private and cant create multiple objects */
}
public function getQuery(){
return "Test Query Data";
}
}
$dbObj = Database::getInstance();
$dbObj2 = Database::getInstance();
var_dump($dbObj);
var_dump($dbObj2);
/*
After execution you will get following output:
object(Database)[1]
object(Database)[1]
*/
Ref http://www.phptechi.com/php-singleton -Design-Muster-example.html
Dies ist das Beispiel von Singleton auf Datenbank-Klasse erstellen
Design Patterns 1) Singleton
class Database{
public static $instance;
public static function getInstance(){
if(!isset(Database::$instance)){
Database::$instance=new Database();
return Database::$instance;
}
}
$db=Database::getInstance();
$db2=Database::getInstance();
$db3=Database::getInstance();
var_dump($db);
var_dump($db2);
var_dump($db3);
dann außer Betrieb gesetzt ist -
object(Database)[1]
object(Database)[1]
object(Database)[1]
verwenden nur einzelne Instanz nicht 3-Instanz erstellen
Hier ist mein Beispiel die Fähigkeit, als $ var = new Singleton () und auch drei Variablen zu schaffen aufrufen bietet zu testen, ob es neu erstellt Objekt:
class Singleton{
private static $data;
function __construct(){
if ($this::$data == null){
$this->makeSingleton();
}
echo "<br/>".$this::$data;
}
private function makeSingleton(){
$this::$data = rand(0, 100);
}
public function change($new_val){
$this::$data = $new_val;
}
public function printme(){
echo "<br/>".$this::$data;
}
}
$a = new Singleton();
$b = new Singleton();
$c = new Singleton();
$a->change(-2);
$a->printme();
$b->printme();
$d = new Singleton();
$d->printme();
